Data.Semiring

A class for semirings (types with two binary operations, one commutative and one associative, and two respective identites), with various general-purpose instances.

Semiring typeclass

class Semiring a where

The class of semirings (types with two binary operations and two respective identities). One can think of a semiring as two monoids of the same underlying type: A commutative monoid and an associative monoid. For any type R with a Num instance, the commutative monoid is (R, '(Prelude.+)', 0) and the associative monoid is (R, '(Prelude.*)', 1).

Instances should satisfy the following laws:

additive identity

x + zero = zero + x = x

additive associativity

x + (y + z) = (x + y) + z

additive commutativity

x + y = y + x

multiplicative identity

x * one = one * x = x

multiplicative associativity

x * (y * z) = (x * y) * z

left- and right-distributivity of * over +

x * (y + z) = (x * y) + (x * z) (x + y) * z = (x * z) + (y * z)

annihilation

zero * x = x * zero = zero

Minimal complete definition

plus, zero, times, one

Methods

plus infixl 6

Arguments

:: a

-> a

-> a

Commutative Operation

zero

Arguments

:: a

Commutative Unit

times infixl 7

Arguments

:: a

-> a

-> a

Associative Operation

one

Arguments

:: a

Associative Unit

Instances

Semiring Bool

Defined in Data.Semiring

Methods

plus :: Bool -> Bool -> Bool

zero :: Bool

times :: Bool -> Bool -> Bool

one :: Bool

Semiring Double

Defined in Data.Semiring

Methods

plus :: Double -> Double -> Double

zero :: Double

times :: Double -> Double -> Double

one :: Double

Semiring Float

Defined in Data.Semiring

Methods

plus :: Float -> Float -> Float

zero :: Float

times :: Float -> Float -> Float

one :: Float

Semiring Int

Defined in Data.Semiring

Methods

plus :: Int -> Int -> Int

zero :: Int

times :: Int -> Int -> Int

one :: Int

Semiring Int8

Defined in Data.Semiring

Methods

plus :: Int8 -> Int8 -> Int8

zero :: Int8

times :: Int8 -> Int8 -> Int8

one :: Int8

Semiring Int16

Defined in Data.Semiring

Methods

plus :: Int16 -> Int16 -> Int16

zero :: Int16

times :: Int16 -> Int16 -> Int16

one :: Int16

Semiring Int32

Defined in Data.Semiring

Methods

plus :: Int32 -> Int32 -> Int32

zero :: Int32

times :: Int32 -> Int32 -> Int32

one :: Int32

Semiring Int64

Defined in Data.Semiring

Methods

plus :: Int64 -> Int64 -> Int64

zero :: Int64

times :: Int64 -> Int64 -> Int64

one :: Int64

Semiring Integer

Defined in Data.Semiring

Methods

plus :: Integer -> Integer -> Integer

zero :: Integer

times :: Integer -> Integer -> Integer

one :: Integer

Semiring Natural

Defined in Data.Semiring

Methods

plus :: Natural -> Natural -> Natural

zero :: Natural

times :: Natural -> Natural -> Natural

one :: Natural

Semiring Word

Defined in Data.Semiring

Methods

plus :: Word -> Word -> Word

zero :: Word

times :: Word -> Word -> Word

one :: Word

Semiring Word8

Defined in Data.Semiring

Methods

plus :: Word8 -> Word8 -> Word8

zero :: Word8

times :: Word8 -> Word8 -> Word8

one :: Word8

Semiring Word16

Defined in Data.Semiring

Methods

plus :: Word16 -> Word16 -> Word16

zero :: Word16

times :: Word16 -> Word16 -> Word16

one :: Word16

Semiring Word32

Defined in Data.Semiring

Methods

plus :: Word32 -> Word32 -> Word32

zero :: Word32

times :: Word32 -> Word32 -> Word32

one :: Word32

Semiring Word64

Defined in Data.Semiring

Methods

plus :: Word64 -> Word64 -> Word64

zero :: Word64

times :: Word64 -> Word64 -> Word64

one :: Word64

Semiring ()

Defined in Data.Semiring

Methods

plus :: () -> () -> ()

zero :: ()

times :: () -> () -> ()

one :: ()

Semiring CDev

Defined in Data.Semiring

Methods

plus :: CDev -> CDev -> CDev

zero :: CDev

times :: CDev -> CDev -> CDev

one :: CDev

Semiring CIno

Defined in Data.Semiring

Methods

plus :: CIno -> CIno -> CIno

zero :: CIno

times :: CIno -> CIno -> CIno

one :: CIno

Semiring CMode

Defined in Data.Semiring

Methods

plus :: CMode -> CMode -> CMode

zero :: CMode

times :: CMode -> CMode -> CMode

one :: CMode

Semiring COff

Defined in Data.Semiring

Methods

plus :: COff -> COff -> COff

zero :: COff

times :: COff -> COff -> COff

one :: COff

Semiring CPid

Defined in Data.Semiring

Methods

plus :: CPid -> CPid -> CPid

zero :: CPid

times :: CPid -> CPid -> CPid

one :: CPid

Semiring CSsize

Defined in Data.Semiring

Methods

plus :: CSsize -> CSsize -> CSsize

zero :: CSsize

times :: CSsize -> CSsize -> CSsize

one :: CSsize

Semiring CGid

Defined in Data.Semiring

Methods

plus :: CGid -> CGid -> CGid

zero :: CGid

times :: CGid -> CGid -> CGid

one :: CGid

Semiring CNlink

Defined in Data.Semiring

Methods

plus :: CNlink -> CNlink -> CNlink

zero :: CNlink

times :: CNlink -> CNlink -> CNlink

one :: CNlink

Semiring CUid

Defined in Data.Semiring

Methods

plus :: CUid -> CUid -> CUid

zero :: CUid

times :: CUid -> CUid -> CUid

one :: CUid

Semiring CCc

Defined in Data.Semiring

Methods

plus :: CCc -> CCc -> CCc

zero :: CCc

times :: CCc -> CCc -> CCc

one :: CCc

Semiring CSpeed

Defined in Data.Semiring

Methods

plus :: CSpeed -> CSpeed -> CSpeed

zero :: CSpeed

times :: CSpeed -> CSpeed -> CSpeed

one :: CSpeed

Semiring CTcflag

Defined in Data.Semiring

Methods

plus :: CTcflag -> CTcflag -> CTcflag

zero :: CTcflag

times :: CTcflag -> CTcflag -> CTcflag

one :: CTcflag

Semiring CRLim

Defined in Data.Semiring

Methods

plus :: CRLim -> CRLim -> CRLim

zero :: CRLim

times :: CRLim -> CRLim -> CRLim

one :: CRLim

Semiring Fd

Defined in Data.Semiring

Methods

plus :: Fd -> Fd -> Fd

zero :: Fd

times :: Fd -> Fd -> Fd

one :: Fd

Semiring CChar

Defined in Data.Semiring

Methods

plus :: CChar -> CChar -> CChar

zero :: CChar

times :: CChar -> CChar -> CChar

one :: CChar

Semiring CSChar

Defined in Data.Semiring

Methods

plus :: CSChar -> CSChar -> CSChar

zero :: CSChar

times :: CSChar -> CSChar -> CSChar

one :: CSChar

Semiring CUChar

Defined in Data.Semiring

Methods

plus :: CUChar -> CUChar -> CUChar

zero :: CUChar

times :: CUChar -> CUChar -> CUChar

one :: CUChar

Semiring CShort

Defined in Data.Semiring

Methods

plus :: CShort -> CShort -> CShort

zero :: CShort

times :: CShort -> CShort -> CShort

one :: CShort

Semiring CUShort

Defined in Data.Semiring

Methods

plus :: CUShort -> CUShort -> CUShort

zero :: CUShort

times :: CUShort -> CUShort -> CUShort

one :: CUShort

Semiring CInt

Defined in Data.Semiring

Methods

plus :: CInt -> CInt -> CInt

zero :: CInt

times :: CInt -> CInt -> CInt

one :: CInt

Semiring CUInt

Defined in Data.Semiring

Methods

plus :: CUInt -> CUInt -> CUInt

zero :: CUInt

times :: CUInt -> CUInt -> CUInt

one :: CUInt

Semiring CLong

Defined in Data.Semiring

Methods

plus :: CLong -> CLong -> CLong

zero :: CLong

times :: CLong -> CLong -> CLong

one :: CLong

Semiring CULong

Defined in Data.Semiring

Methods

plus :: CULong -> CULong -> CULong

zero :: CULong

times :: CULong -> CULong -> CULong

one :: CULong

Semiring CLLong

Defined in Data.Semiring

Methods

plus :: CLLong -> CLLong -> CLLong

zero :: CLLong

times :: CLLong -> CLLong -> CLLong

one :: CLLong

Semiring CULLong

Defined in Data.Semiring

Methods

plus :: CULLong -> CULLong -> CULLong

zero :: CULLong

times :: CULLong -> CULLong -> CULLong

one :: CULLong

Semiring CFloat

Defined in Data.Semiring

Methods

plus :: CFloat -> CFloat -> CFloat

zero :: CFloat

times :: CFloat -> CFloat -> CFloat

one :: CFloat

Semiring CDouble

Defined in Data.Semiring

Methods

plus :: CDouble -> CDouble -> CDouble

zero :: CDouble

times :: CDouble -> CDouble -> CDouble

one :: CDouble

Semiring CPtrdiff

Defined in Data.Semiring

Methods

plus :: CPtrdiff -> CPtrdiff -> CPtrdiff

zero :: CPtrdiff

times :: CPtrdiff -> CPtrdiff -> CPtrdiff

one :: CPtrdiff

Semiring CSize

Defined in Data.Semiring

Methods

plus :: CSize -> CSize -> CSize

zero :: CSize

times :: CSize -> CSize -> CSize

one :: CSize

Semiring CWchar

Defined in Data.Semiring

Methods

plus :: CWchar -> CWchar -> CWchar

zero :: CWchar

times :: CWchar -> CWchar -> CWchar

one :: CWchar

Semiring CSigAtomic

Defined in Data.Semiring

Methods

plus :: CSigAtomic -> CSigAtomic -> CSigAtomic

zero :: CSigAtomic

times :: CSigAtomic -> CSigAtomic -> CSigAtomic

one :: CSigAtomic

Semiring CClock

Defined in Data.Semiring

Methods

plus :: CClock -> CClock -> CClock

zero :: CClock

times :: CClock -> CClock -> CClock

one :: CClock

Semiring CTime

Defined in Data.Semiring

Methods

plus :: CTime -> CTime -> CTime

zero :: CTime

times :: CTime -> CTime -> CTime

one :: CTime

Semiring CUSeconds

Defined in Data.Semiring

Methods

plus :: CUSeconds -> CUSeconds -> CUSeconds

zero :: CUSeconds

times :: CUSeconds -> CUSeconds -> CUSeconds

one :: CUSeconds

Semiring CSUSeconds

Defined in Data.Semiring

Methods

plus :: CSUSeconds -> CSUSeconds -> CSUSeconds

zero :: CSUSeconds

times :: CSUSeconds -> CSUSeconds -> CSUSeconds

one :: CSUSeconds

Semiring CIntPtr

Defined in Data.Semiring

Methods

plus :: CIntPtr -> CIntPtr -> CIntPtr

zero :: CIntPtr

times :: CIntPtr -> CIntPtr -> CIntPtr

one :: CIntPtr

Semiring CUIntPtr

Defined in Data.Semiring

Methods

plus :: CUIntPtr -> CUIntPtr -> CUIntPtr

zero :: CUIntPtr

times :: CUIntPtr -> CUIntPtr -> CUIntPtr

one :: CUIntPtr

Semiring CIntMax

Defined in Data.Semiring

Methods

plus :: CIntMax -> CIntMax -> CIntMax

zero :: CIntMax

times :: CIntMax -> CIntMax -> CIntMax

one :: CIntMax

Semiring CUIntMax

Defined in Data.Semiring

Methods

plus :: CUIntMax -> CUIntMax -> CUIntMax

zero :: CUIntMax

times :: CUIntMax -> CUIntMax -> CUIntMax

one :: CUIntMax

Semiring WordPtr

Defined in Data.Semiring

Methods

plus :: WordPtr -> WordPtr -> WordPtr

zero :: WordPtr

times :: WordPtr -> WordPtr -> WordPtr

one :: WordPtr

Semiring IntPtr

Defined in Data.Semiring

Methods

plus :: IntPtr -> IntPtr -> IntPtr

zero :: IntPtr

times :: IntPtr -> IntPtr -> IntPtr

one :: IntPtr

Semiring a => Semiring [a]

Defined in Data.Semiring

Methods

plus :: [a] -> [a] -> [a]

zero :: [a]

times :: [a] -> [a] -> [a]

one :: [a]

Semiring a => Semiring (Maybe a)

Defined in Data.Semiring

Methods

plus :: Maybe a -> Maybe a -> Maybe a

zero :: Maybe a

times :: Maybe a -> Maybe a -> Maybe a

one :: Maybe a

Integral a => Semiring (Ratio a)

Defined in Data.Semiring

Methods

plus :: Ratio a -> Ratio a -> Ratio a

zero :: Ratio a

times :: Ratio a -> Ratio a -> Ratio a

one :: Ratio a

Semiring a => Semiring (IO a)

Defined in Data.Semiring

Methods

plus :: IO a -> IO a -> IO a

zero :: IO a

times :: IO a -> IO a -> IO a

one :: IO a

Ring a => Semiring (Complex a)

This instance can suffer due to floating point arithmetic.

Defined in Data.Semiring

Methods

plus :: Complex a -> Complex a -> Complex a

zero :: Complex a

times :: Complex a -> Complex a -> Complex a

one :: Complex a

HasResolution a => Semiring (Fixed a)

Defined in Data.Semiring

Methods

plus :: Fixed a -> Fixed a -> Fixed a

zero :: Fixed a

times :: Fixed a -> Fixed a -> Fixed a

one :: Fixed a

Semiring a => Semiring (Min a)

Defined in Data.Semiring

Methods

plus :: Min a -> Min a -> Min a

zero :: Min a

times :: Min a -> Min a -> Min a

one :: Min a

Semiring a => Semiring (Max a)

Defined in Data.Semiring

Methods

plus :: Max a -> Max a -> Max a

zero :: Max a

times :: Max a -> Max a -> Max a

one :: Max a

Semiring a => Semiring (Identity a)

Defined in Data.Semiring

Methods

plus :: Identity a -> Identity a -> Identity a

zero :: Identity a

times :: Identity a -> Identity a -> Identity a

one :: Identity a

Semiring a => Semiring (Dual a)

Defined in Data.Semiring

Methods

plus :: Dual a -> Dual a -> Dual a

zero :: Dual a

times :: Dual a -> Dual a -> Dual a

one :: Dual a

Semiring a => Semiring (Sum a)

Defined in Data.Semiring

Methods

plus :: Sum a -> Sum a -> Sum a

zero :: Sum a

times :: Sum a -> Sum a -> Sum a

one :: Sum a

Semiring a => Semiring (Product a)

Defined in Data.Semiring

Methods

plus :: Product a -> Product a -> Product a

zero :: Product a

times :: Product a -> Product a -> Product a

one :: Product a

Semiring a => Semiring (Down a)

Defined in Data.Semiring

Methods

plus :: Down a -> Down a -> Down a

zero :: Down a

times :: Down a -> Down a -> Down a

one :: Down a

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

The multiplication laws are satisfied for any underlying Monoid, so we require a Monoid contraint instead of a Semiring constraint since times can use the context of either.

Defined in Data.Semiring

Methods

plus :: Set a -> Set a -> Set a

zero :: Set a

times :: Set a -> Set a -> Set a

one :: Set a

(Eq a, Hashable a, Monoid a) => Semiring (HashSet a)

The multiplication laws are satisfied for any underlying Monoid, so we require a Monoid contraint instead of a Semiring constraint since times can use the context of either.

Defined in Data.Semiring

Methods

plus :: HashSet a -> HashSet a -> HashSet a

zero :: HashSet a

times :: HashSet a -> HashSet a -> HashSet a

one :: HashSet a

(Unbox a, Semiring a) => Semiring (Vector a)

Defined in Data.Semiring

Methods

plus :: Vector a -> Vector a -> Vector a

zero :: Vector a

times :: Vector a -> Vector a -> Vector a

one :: Vector a

(Storable a, Semiring a) => Semiring (Vector a)

Defined in Data.Semiring

Methods

plus :: Vector a -> Vector a -> Vector a

zero :: Vector a

times :: Vector a -> Vector a -> Vector a

one :: Vector a

Semiring a => Semiring (Vector a)

Defined in Data.Semiring

Methods

plus :: Vector a -> Vector a -> Vector a

zero :: Vector a

times :: Vector a -> Vector a -> Vector a

one :: Vector a

Num a => Semiring (WrappedNum a)

Defined in Data.Semiring

Methods

plus :: WrappedNum a -> WrappedNum a -> WrappedNum a

zero :: WrappedNum a

times :: WrappedNum a -> WrappedNum a -> WrappedNum a

one :: WrappedNum a

Semiring a => Semiring (Mul a)

Defined in Data.Semiring

Methods

plus :: Mul a -> Mul a -> Mul a

zero :: Mul a

times :: Mul a -> Mul a -> Mul a

one :: Mul a

Semiring a => Semiring (Add a)

Defined in Data.Semiring

Methods

plus :: Add a -> Add a -> Add a

zero :: Add a

times :: Add a -> Add a -> Add a

one :: Add a

Semiring b => Semiring (a -> b)

Defined in Data.Semiring

Methods

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

zero :: a -> b

times :: (a -> b) -> (a -> b) -> a -> b

one :: a -> b

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

Defined in Data.Semiring.Generic

Methods

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

zero :: (a, b)

times :: (a, b) -> (a, b) -> (a, b)

one :: (a, b)

Semiring (Proxy a)

Defined in Data.Semiring

Methods

plus :: Proxy a -> Proxy a -> Proxy a

zero :: Proxy a

times :: Proxy a -> Proxy a -> Proxy a

one :: Proxy a

(Ord k, Monoid k, Semiring v) => Semiring (Map k v)

The multiplication laws are satisfied for any underlying Monoid as the key type, so we require a Monoid contraint instead of a Semiring constraint since times can use the context of either.

Defined in Data.Semiring

Methods

plus :: Map k v -> Map k v -> Map k v

zero :: Map k v

times :: Map k v -> Map k v -> Map k v

one :: Map k v

(Eq k, Hashable k, Monoid k, Semiring v) => Semiring (HashMap k v)

The multiplication laws are satisfied for any underlying Monoid as the key type, so we require a Monoid contraint instead of a Semiring constraint since times can use the context of either.

Defined in Data.Semiring

Methods

plus :: HashMap k v -> HashMap k v -> HashMap k v

zero :: HashMap k v

times :: HashMap k v -> HashMap k v -> HashMap k v

one :: HashMap k v

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

Defined in Data.Semiring.Generic

Methods

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

zero :: (a, b, c)

times :: (a, b, c) -> (a, b, c) -> (a, b, c)

one :: (a, b, c)

Semiring a => Semiring (Const a b)

Defined in Data.Semiring

Methods

plus :: Const a b -> Const a b -> Const a b

zero :: Const a b

times :: Const a b -> Const a b -> Const a b

one :: Const a b

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

Defined in Data.Semiring.Generic

Methods

plus :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

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

times :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

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

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

Defined in Data.Semiring.Generic

Methods

plus :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

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

times :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

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

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

Defined in Data.Semiring.Generic

Methods

plus :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

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

times :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

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

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

Defined in Data.Semiring.Generic

Methods

plus :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

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

times :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

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

(+) :: Semiring a => a -> a -> a infixl 6

Infix shorthand for plus.

(*) :: Semiring a => a -> a -> a infixl 7

Infix shorthand for times.

(^) :: (Semiring a, Integral b) => a -> b -> a infixr 8

Raise a number to a non-negative integral power. If the power is negative, this will return zero.

foldMapP :: (Foldable t, Semiring s) => (a -> s) -> t a -> s

Map each element of the structure to a semiring, and combine the results using plus.

foldMapT :: (Foldable t, Semiring s) => (a -> s) -> t a -> s

Map each element of the structure to a semiring, and combine the results using times.

sum :: (Foldable t, Semiring a) => t a -> a

The sum function computes the additive sum of the elements in a structure. This function is lazy. For a strict version, see sum'.

product :: (Foldable t, Semiring a) => t a -> a

The product function computes the product of the elements in a structure. This function is lazy. for a strict version, see product'.

sum' :: (Foldable t, Semiring a) => t a -> a

The sum' function computes the additive sum of the elements in a structure. This function is strict. For a lazy version, see sum.

product' :: (Foldable t, Semiring a) => t a -> a

The product' function computes the additive sum of the elements in a structure. This function is strict. For a lazy version, see product.

Types

newtype Add a

Monoid under plus. Analogous to Sum, but uses the Semiring constraint rather than Num.

Constructors

Add

Fields

• getAdd :: a

Instances

Functor Add

Defined in Data.Semiring

Methods

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

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

Foldable Add

Defined in Data.Semiring

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

Defined in Data.Semiring

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)

Bounded a => Bounded (Add a)

Defined in Data.Semiring

Methods

minBound :: Add a

maxBound :: Add a

Enum a => Enum (Add a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Add a)

Defined in Data.Semiring

Methods

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

recip :: Add a -> Add a

fromRational :: Rational -> Add a

Num a => Num (Add a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Add a)

readList :: ReadS [Add a]

readPrec :: ReadPrec (Add a)

readListPrec :: ReadPrec [Add a]

Real a => Real (Add a)

Defined in Data.Semiring

Methods

toRational :: Add a -> Rational

RealFrac a => RealFrac (Add a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Add a -> ShowS

show :: Add a -> String

showList :: [Add a] -> ShowS

Generic (Add a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

mempty :: Add a

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

mconcat :: [Add a] -> Add a

Storable a => Storable (Add a)

Defined in Data.Semiring

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

Semiring a => Semiring (Add a)

Defined in Data.Semiring

Methods

plus :: Add a -> Add a -> Add a

zero :: Add a

times :: Add a -> Add a -> Add a

one :: Add a

Generic1 Add

Defined in Data.Semiring

Associated Types

type Rep1 Add :: k -> *

Methods

from1 :: Add a -> Rep1 Add a

to1 :: Rep1 Add a -> Add a

type Rep (Add a)

Defined in Data.Semiring

type Rep (Add a) = D1 (MetaData "Add" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Add

Defined in Data.Semiring

type Rep1 Add = D1 (MetaData "Add" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "Add" PrefixI True) (S1 (MetaSel (Just "getAdd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype Mul a

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

Constructors

Mul

Fields

• getMul :: a

Instances

Functor Mul

Defined in Data.Semiring

Methods

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

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

Foldable Mul

Defined in Data.Semiring

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

Defined in Data.Semiring

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)

Bounded a => Bounded (Mul a)

Defined in Data.Semiring

Methods

minBound :: Mul a

maxBound :: Mul a

Enum a => Enum (Mul a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (Mul a)

Defined in Data.Semiring

Methods

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

recip :: Mul a -> Mul a

fromRational :: Rational -> Mul a

Num a => Num (Mul a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (Mul a)

readList :: ReadS [Mul a]

readPrec :: ReadPrec (Mul a)

readListPrec :: ReadPrec [Mul a]

Real a => Real (Mul a)

Defined in Data.Semiring

Methods

toRational :: Mul a -> Rational

RealFrac a => RealFrac (Mul a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

showsPrec :: Int -> Mul a -> ShowS

show :: Mul a -> String

showList :: [Mul a] -> ShowS

Generic (Mul a)

Defined in Data.Semiring

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)

Defined in Data.Semiring

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)

Defined in Data.Semiring

Methods

mempty :: Mul a

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

mconcat :: [Mul a] -> Mul a

Storable a => Storable (Mul a)

Defined in Data.Semiring

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

Semiring a => Semiring (Mul a)

Defined in Data.Semiring

Methods

plus :: Mul a -> Mul a -> Mul a

zero :: Mul a

times :: Mul a -> Mul a -> Mul a

one :: Mul a

Generic1 Mul

Defined in Data.Semiring

Associated Types

type Rep1 Mul :: k -> *

Methods

from1 :: Mul a -> Rep1 Mul a

to1 :: Rep1 Mul a -> Mul a

type Rep (Mul a)

Defined in Data.Semiring

type Rep (Mul a) = D1 (MetaData "Mul" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Mul

Defined in Data.Semiring

type Rep1 Mul = D1 (MetaData "Mul" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "Mul" PrefixI True) (S1 (MetaSel (Just "getMul") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

newtype WrappedNum a

Provide Semiring and Ring for an arbitrary Num. It is useful with GHC 8.6+'s DerivingVia extension.

Constructors

WrapNum

Fields

• unwrapNum :: a

Instances

Functor WrappedNum

Defined in Data.Semiring

Methods

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

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

Foldable WrappedNum

Defined in Data.Semiring

Methods

fold :: Monoid m => WrappedNum m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> WrappedNum a -> a

foldl1 :: (a -> a -> a) -> WrappedNum a -> a

toList :: WrappedNum a -> [a]

null :: WrappedNum a -> Bool

length :: WrappedNum a -> Int

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

maximum :: Ord a => WrappedNum a -> a

minimum :: Ord a => WrappedNum a -> a

sum :: Num a => WrappedNum a -> a

product :: Num a => WrappedNum a -> a

Traversable WrappedNum

Defined in Data.Semiring

Methods

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

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

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

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

Bounded a => Bounded (WrappedNum a)

Defined in Data.Semiring

Methods

minBound :: WrappedNum a

maxBound :: WrappedNum a

Enum a => Enum (WrappedNum a)

Defined in Data.Semiring

Methods

succ :: WrappedNum a -> WrappedNum a

pred :: WrappedNum a -> WrappedNum a

toEnum :: Int -> WrappedNum a

fromEnum :: WrappedNum a -> Int

enumFrom :: WrappedNum a -> [WrappedNum a]

enumFromThen :: WrappedNum a -> WrappedNum a -> [WrappedNum a]

enumFromTo :: WrappedNum a -> WrappedNum a -> [WrappedNum a]

enumFromThenTo :: WrappedNum a -> WrappedNum a -> WrappedNum a -> [WrappedNum a]

Eq a => Eq (WrappedNum a)

Defined in Data.Semiring

Methods

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

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

Fractional a => Fractional (WrappedNum a)

Defined in Data.Semiring

Methods

(/) :: WrappedNum a -> WrappedNum a -> WrappedNum a

recip :: WrappedNum a -> WrappedNum a

fromRational :: Rational -> WrappedNum a

Num a => Num (WrappedNum a)

Defined in Data.Semiring

Methods

(+) :: WrappedNum a -> WrappedNum a -> WrappedNum a

(-) :: WrappedNum a -> WrappedNum a -> WrappedNum a

(*) :: WrappedNum a -> WrappedNum a -> WrappedNum a

negate :: WrappedNum a -> WrappedNum a

abs :: WrappedNum a -> WrappedNum a

signum :: WrappedNum a -> WrappedNum a

fromInteger :: Integer -> WrappedNum a

Ord a => Ord (WrappedNum a)

Defined in Data.Semiring

Methods

compare :: WrappedNum a -> WrappedNum a -> Ordering

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

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

(>) :: WrappedNum a -> WrappedNum a -> Bool

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

max :: WrappedNum a -> WrappedNum a -> WrappedNum a

min :: WrappedNum a -> WrappedNum a -> WrappedNum a

Read a => Read (WrappedNum a)

Defined in Data.Semiring

Methods

readsPrec :: Int -> ReadS (WrappedNum a)

readList :: ReadS [WrappedNum a]

readPrec :: ReadPrec (WrappedNum a)

readListPrec :: ReadPrec [WrappedNum a]

Real a => Real (WrappedNum a)

Defined in Data.Semiring

Methods

toRational :: WrappedNum a -> Rational

RealFrac a => RealFrac (WrappedNum a)

Defined in Data.Semiring

Methods

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

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

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

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

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

Show a => Show (WrappedNum a)

Defined in Data.Semiring

Methods

showsPrec :: Int -> WrappedNum a -> ShowS

show :: WrappedNum a -> String

showList :: [WrappedNum a] -> ShowS

Generic (WrappedNum a)

Defined in Data.Semiring

Associated Types

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

Methods

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

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

Storable a => Storable (WrappedNum a)

Defined in Data.Semiring

Methods

sizeOf :: WrappedNum a -> Int

alignment :: WrappedNum a -> Int

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

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

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

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

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

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

Num a => Ring (WrappedNum a)

Defined in Data.Semiring

Methods

negate :: WrappedNum a -> WrappedNum a

Num a => Semiring (WrappedNum a)

Defined in Data.Semiring

Methods

plus :: WrappedNum a -> WrappedNum a -> WrappedNum a

zero :: WrappedNum a

times :: WrappedNum a -> WrappedNum a -> WrappedNum a

one :: WrappedNum a

Generic1 WrappedNum

Defined in Data.Semiring

Associated Types

type Rep1 WrappedNum :: k -> *

Methods

from1 :: WrappedNum a -> Rep1 WrappedNum a

to1 :: Rep1 WrappedNum a -> WrappedNum a

type Rep (WrappedNum a)

Defined in Data.Semiring

type Rep (WrappedNum a) = D1 (MetaData "WrappedNum" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "WrapNum" PrefixI True) (S1 (MetaSel (Just "unwrapNum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 WrappedNum

Defined in Data.Semiring

type Rep1 WrappedNum = D1 (MetaData "WrappedNum" "Data.Semiring" "semirings-0.2.1.1-K4F9vEfdMGEFaB4LacyWRO" True) (C1 (MetaCons "WrapNum" PrefixI True) (S1 (MetaSel (Just "unwrapNum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

Ring typeclass

class Semiring a => Ring a where

The class of semirings with an additive inverse.

negate a + a = zero

Minimal complete definition

negate

Methods

negate :: a -> a

Instances

Ring Bool

Defined in Data.Semiring

Methods

negate :: Bool -> Bool

Ring Double

Defined in Data.Semiring

Methods

negate :: Double -> Double

Ring Float

Defined in Data.Semiring

Methods

negate :: Float -> Float

Ring Int

Defined in Data.Semiring

Methods

negate :: Int -> Int

Ring Int8

Defined in Data.Semiring

Methods

negate :: Int8 -> Int8

Ring Int16

Defined in Data.Semiring

Methods

negate :: Int16 -> Int16

Ring Int32

Defined in Data.Semiring

Methods

negate :: Int32 -> Int32

Ring Int64

Defined in Data.Semiring

Methods

negate :: Int64 -> Int64

Ring Integer

Defined in Data.Semiring

Methods

negate :: Integer -> Integer

Ring Natural

Defined in Data.Semiring

Methods

negate :: Natural -> Natural

Ring Word

Defined in Data.Semiring

Methods

negate :: Word -> Word

Ring Word8

Defined in Data.Semiring

Methods

negate :: Word8 -> Word8

Ring Word16

Defined in Data.Semiring

Methods

negate :: Word16 -> Word16

Ring Word32

Defined in Data.Semiring

Methods

negate :: Word32 -> Word32

Ring Word64

Defined in Data.Semiring

Methods

negate :: Word64 -> Word64

Ring ()

Defined in Data.Semiring

Methods

negate :: () -> ()

Ring CDev

Defined in Data.Semiring

Methods

negate :: CDev -> CDev

Ring CIno

Defined in Data.Semiring

Methods

negate :: CIno -> CIno

Ring CMode

Defined in Data.Semiring

Methods

negate :: CMode -> CMode

Ring COff

Defined in Data.Semiring

Methods

negate :: COff -> COff

Ring CPid

Defined in Data.Semiring

Methods

negate :: CPid -> CPid

Ring CSsize

Defined in Data.Semiring

Methods

negate :: CSsize -> CSsize

Ring CGid

Defined in Data.Semiring

Methods

negate :: CGid -> CGid

Ring CNlink

Defined in Data.Semiring

Methods

negate :: CNlink -> CNlink

Ring CUid

Defined in Data.Semiring

Methods

negate :: CUid -> CUid

Ring CCc

Defined in Data.Semiring

Methods

negate :: CCc -> CCc

Ring CSpeed

Defined in Data.Semiring

Methods

negate :: CSpeed -> CSpeed

Ring CTcflag

Defined in Data.Semiring

Methods

negate :: CTcflag -> CTcflag

Ring CRLim

Defined in Data.Semiring

Methods

negate :: CRLim -> CRLim

Ring Fd

Defined in Data.Semiring

Methods

negate :: Fd -> Fd

Ring CChar

Defined in Data.Semiring

Methods

negate :: CChar -> CChar

Ring CSChar

Defined in Data.Semiring

Methods

negate :: CSChar -> CSChar

Ring CUChar

Defined in Data.Semiring

Methods

negate :: CUChar -> CUChar

Ring CShort

Defined in Data.Semiring

Methods

negate :: CShort -> CShort

Ring CUShort

Defined in Data.Semiring

Methods

negate :: CUShort -> CUShort

Ring CInt

Defined in Data.Semiring

Methods

negate :: CInt -> CInt

Ring CUInt

Defined in Data.Semiring

Methods

negate :: CUInt -> CUInt

Ring CLong

Defined in Data.Semiring

Methods

negate :: CLong -> CLong

Ring CULong

Defined in Data.Semiring

Methods

negate :: CULong -> CULong

Ring CLLong

Defined in Data.Semiring

Methods

negate :: CLLong -> CLLong

Ring CULLong

Defined in Data.Semiring

Methods

negate :: CULLong -> CULLong

Ring CFloat

Defined in Data.Semiring

Methods

negate :: CFloat -> CFloat

Ring CDouble

Defined in Data.Semiring

Methods

negate :: CDouble -> CDouble

Ring CPtrdiff

Defined in Data.Semiring

Methods

negate :: CPtrdiff -> CPtrdiff

Ring CSize

Defined in Data.Semiring

Methods

negate :: CSize -> CSize

Ring CWchar

Defined in Data.Semiring

Methods

negate :: CWchar -> CWchar

Ring CSigAtomic

Defined in Data.Semiring

Methods

negate :: CSigAtomic -> CSigAtomic

Ring CClock

Defined in Data.Semiring

Methods

negate :: CClock -> CClock

Ring CTime

Defined in Data.Semiring

Methods

negate :: CTime -> CTime

Ring CUSeconds

Defined in Data.Semiring

Methods

negate :: CUSeconds -> CUSeconds

Ring CSUSeconds

Defined in Data.Semiring

Methods

negate :: CSUSeconds -> CSUSeconds

Ring CIntPtr

Defined in Data.Semiring

Methods

negate :: CIntPtr -> CIntPtr

Ring CUIntPtr

Defined in Data.Semiring

Methods

negate :: CUIntPtr -> CUIntPtr

Ring CIntMax

Defined in Data.Semiring

Methods

negate :: CIntMax -> CIntMax

Ring CUIntMax

Defined in Data.Semiring

Methods

negate :: CUIntMax -> CUIntMax

Ring WordPtr

Defined in Data.Semiring

Methods

negate :: WordPtr -> WordPtr

Ring IntPtr

Defined in Data.Semiring

Methods

negate :: IntPtr -> IntPtr

Ring a => Ring [a]

Defined in Data.Semiring

Methods

negate :: [a] -> [a]

Ring a => Ring (Maybe a)

Defined in Data.Semiring

Methods

negate :: Maybe a -> Maybe a

Integral a => Ring (Ratio a)

Defined in Data.Semiring

Methods

negate :: Ratio a -> Ratio a

Ring a => Ring (IO a)

Defined in Data.Semiring

Methods

negate :: IO a -> IO a

Ring a => Ring (Complex a)

Defined in Data.Semiring

Methods

negate :: Complex a -> Complex a

HasResolution a => Ring (Fixed a)

Defined in Data.Semiring

Methods

negate :: Fixed a -> Fixed a

Ring a => Ring (Min a)

Defined in Data.Semiring

Methods

negate :: Min a -> Min a

Ring a => Ring (Max a)

Defined in Data.Semiring

Methods

negate :: Max a -> Max a

Ring a => Ring (Identity a)

Defined in Data.Semiring

Methods

negate :: Identity a -> Identity a

Ring a => Ring (Dual a)

Defined in Data.Semiring

Methods

negate :: Dual a -> Dual a

Ring a => Ring (Sum a)

Defined in Data.Semiring

Methods

negate :: Sum a -> Sum a

Ring a => Ring (Product a)

Defined in Data.Semiring

Methods

negate :: Product a -> Product a

Ring a => Ring (Down a)

Defined in Data.Semiring

Methods

negate :: Down a -> Down a

(Unbox a, Ring a) => Ring (Vector a)

Defined in Data.Semiring

Methods

negate :: Vector a -> Vector a

(Storable a, Ring a) => Ring (Vector a)

Defined in Data.Semiring

Methods

negate :: Vector a -> Vector a

Ring a => Ring (Vector a)

Defined in Data.Semiring

Methods

negate :: Vector a -> Vector a

Num a => Ring (WrappedNum a)

Defined in Data.Semiring

Methods

negate :: WrappedNum a -> WrappedNum a

Ring b => Ring (a -> b)

Defined in Data.Semiring

Methods

negate :: (a -> b) -> a -> b

(Ring a, Ring b) => Ring (a, b)

Defined in Data.Semiring.Generic

Methods

negate :: (a, b) -> (a, b)

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

Defined in Data.Semiring.Generic

Methods

negate :: (a, b, c) -> (a, b, c)

Ring a => Ring (Const a b)

Defined in Data.Semiring

Methods

negate :: Const a b -> Const a b

(Ring a, Ring b, Ring c, Ring d) => Ring (a, b, c, d)

Defined in Data.Semiring.Generic

Methods

negate :: (a, b, c, d) -> (a, b, c, d)

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

Defined in Data.Semiring.Generic

Methods

negate :: (a, b, c, d, e) -> (a, b, c, d, e)

(Ring a, Ring b, Ring c, Ring d, Ring e, Ring f) => Ring (a, b, c, d, e, f)

Defined in Data.Semiring.Generic

Methods

negate :: (a, b, c, d, e, f) -> (a, b, c, d, e, f)

(Ring a, Ring b, Ring c, Ring d, Ring e, Ring f, Ring g) => Ring (a, b, c, d, e, f, g)

Defined in Data.Semiring.Generic

Methods

negate :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

(-) :: Ring a => a -> a -> a infixl 6

Infix shorthand for minus.

minus :: Ring a => a -> a -> a infixl 6

Substract two Ring values. For any type R with a Num instance, this is the same as '(Prelude.-)'.

x minus y = x + negate y