Data.Semiring.Generic

This module provides generic deriving tools for semirings and rings for product-like structures.

Documentation

class GSemiring f where

Generic Semiring class, used to implement plus, times, zero, and one for product-like types implementing Generic.

Methods

gzero' :: f a

gone' :: f a

gplus' :: f a -> f a -> f a

gtimes' :: f a -> f a -> f a

gfromNatural' :: Natural -> f a

Instances

GSemiring (U1 :: Type -> Type)

Defined in Data.Semiring.Generic

Methods

gzero' :: U1 a

gone' :: U1 a

gplus' :: U1 a -> U1 a -> U1 a

gtimes' :: U1 a -> U1 a -> U1 a

gfromNatural' :: Natural -> U1 a

Semiring a => GSemiring (K1 i a :: Type -> Type)

Defined in Data.Semiring.Generic

Methods

gzero' :: K1 i a a0

gone' :: K1 i a a0

gplus' :: K1 i a a0 -> K1 i a a0 -> K1 i a a0

gtimes' :: K1 i a a0 -> K1 i a a0 -> K1 i a a0

gfromNatural' :: Natural -> K1 i a a0

(GSemiring a, GSemiring b) => GSemiring (a :*: b)

Defined in Data.Semiring.Generic

Methods

gzero' :: (a :*: b) a0

gone' :: (a :*: b) a0

gplus' :: (a :*: b) a0 -> (a :*: b) a0 -> (a :*: b) a0

gtimes' :: (a :*: b) a0 -> (a :*: b) a0 -> (a :*: b) a0

gfromNatural' :: Natural -> (a :*: b) a0

GSemiring a => GSemiring (M1 i c a)

Defined in Data.Semiring.Generic

Methods

gzero' :: M1 i c a a0

gone' :: M1 i c a a0

gplus' :: M1 i c a a0 -> M1 i c a a0 -> M1 i c a a0

gtimes' :: M1 i c a a0 -> M1 i c a a0 -> M1 i c a a0

gfromNatural' :: Natural -> M1 i c a a0

gzero :: (Generic a, GSemiring (Rep a)) => a

Generically generate a Semiring zero for any product-like type implementing Generic.

It is only defined for product types.

gplus gzero a = a = gplus a gzero

gone :: (Generic a, GSemiring (Rep a)) => a

Generically generate a Semiring one for any product-like type implementing Generic.

It is only defined for product types.

gtimes gone a = a = gtimes a gone

gplus :: (Generic a, GSemiring (Rep a)) => a -> a -> a

Generically generate a Semiring plus operation for any type implementing Generic. It is only defined for product types.

gplus a b = gplus b a

gtimes :: (Generic a, GSemiring (Rep a)) => a -> a -> a

Generically generate a Semiring times operation for any type implementing Generic. It is only defined for product types.

gtimes a (gtimes b c) = gtimes (gtimes a b) c
gtimes a gzero = gzero = gtimes gzero a

gfromNatural :: (Generic a, GSemiring (Rep a)) => Natural -> a

Generically generate a Semiring fromNatural for any product-like type implementing Generic.

It is only defined for product types.

class GRing f where

Generic Ring class, used to implement negate for product-like types implementing Generic.

Methods

gnegate' :: f a -> f a

Instances

GRing (U1 :: Type -> Type)

Defined in Data.Semiring.Generic

Methods

gnegate' :: U1 a -> U1 a

Ring a => GRing (K1 i a :: Type -> Type)

Defined in Data.Semiring.Generic

Methods

gnegate' :: K1 i a a0 -> K1 i a a0

(GRing a, GRing b) => GRing (a :*: b)

Defined in Data.Semiring.Generic

Methods

gnegate' :: (a :*: b) a0 -> (a :*: b) a0

GRing a => GRing (M1 i c a)

Defined in Data.Semiring.Generic

Methods

gnegate' :: M1 i c a a0 -> M1 i c a a0

gnegate :: (Generic a, GRing (Rep a)) => a -> a

Generically generate a Ring negate operation for any type implementing Generic. It is only defined for product types.

gplus a (gnegate a) = zero

newtype GenericSemiring a

An Identity-style wrapper with a Generic interface to be used with '-XDerivingVia'.

Constructors

GenericSemiring a

Instances

(Generic a, GSemiring (Rep a)) => Semiring (GenericSemiring a)

Defined in Data.Semiring.Generic

Methods

plus :: GenericSemiring a -> GenericSemiring a -> GenericSemiring a

zero :: GenericSemiring a

times :: GenericSemiring a -> GenericSemiring a -> GenericSemiring a

one :: GenericSemiring a

fromNatural :: Natural -> GenericSemiring a

Orphan instances

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

Methods

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

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

Methods

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

zero :: (a, b)

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

one :: (a, b)

fromNatural :: Natural -> (a, b)

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

Methods

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

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

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)

fromNatural :: Natural -> (a, b, c)

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

Methods

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

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

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)

fromNatural :: Natural -> (a, b, c, d)

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

Methods

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

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

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)

fromNatural :: Natural -> (a, b, c, d, e)

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

Methods

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

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

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)

fromNatural :: Natural -> (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)

Methods

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

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

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)

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