{-# LANGUAGE RebindableSyntax #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, DeriveTraversable #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.YAP.MonoidAdaptors
-- Copyright   :  (c) Ross Paterson 2024
-- License     :  BSD-style (see the file LICENSE)
--
-- Maintainer  :  R.Paterson@city.ac.uk
-- Stability   :  provisional
-- Portability :  portable
--
-- Generalized versions of the monoid adaptor types from "Data.Semigroup".
--
-----------------------------------------------------------------------------

module Data.YAP.MonoidAdaptors (
    Sum(..),
    Product(..),
  ) where

import Data.YAP.Algebra
import Prelude.YAP

import Data.Data (Data)
import GHC.Generics (Generic, Generic1)

-- | A redefinition of the @Sum@ adaptor from "Data.Semigroup" with
-- more general instances.
newtype Sum a = Sum a
    deriving (Sum a
Sum a -> Sum a -> Bounded (Sum a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Sum a
$cminBound :: forall a. Bounded a => Sum a
minBound :: Sum a
$cmaxBound :: forall a. Bounded a => Sum a
maxBound :: Sum a
Bounded, Sum a -> Sum a -> Bool
(Sum a -> Sum a -> Bool) -> (Sum a -> Sum a -> Bool) -> Eq (Sum a)
forall a. Eq a => Sum a -> Sum a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Sum a -> Sum a -> Bool
== :: Sum a -> Sum a -> Bool
$c/= :: forall a. Eq a => Sum a -> Sum a -> Bool
/= :: Sum a -> Sum a -> Bool
Eq, Eq (Sum a)
Eq (Sum a) =>
(Sum a -> Sum a -> Ordering)
-> (Sum a -> Sum a -> Bool)
-> (Sum a -> Sum a -> Bool)
-> (Sum a -> Sum a -> Bool)
-> (Sum a -> Sum a -> Bool)
-> (Sum a -> Sum a -> Sum a)
-> (Sum a -> Sum a -> Sum a)
-> Ord (Sum a)
Sum a -> Sum a -> Bool
Sum a -> Sum a -> Ordering
Sum a -> Sum a -> Sum a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Sum a)
forall a. Ord a => Sum a -> Sum a -> Bool
forall a. Ord a => Sum a -> Sum a -> Ordering
forall a. Ord a => Sum a -> Sum a -> Sum a
$ccompare :: forall a. Ord a => Sum a -> Sum a -> Ordering
compare :: Sum a -> Sum a -> Ordering
$c< :: forall a. Ord a => Sum a -> Sum a -> Bool
< :: Sum a -> Sum a -> Bool
$c<= :: forall a. Ord a => Sum a -> Sum a -> Bool
<= :: Sum a -> Sum a -> Bool
$c> :: forall a. Ord a => Sum a -> Sum a -> Bool
> :: Sum a -> Sum a -> Bool
$c>= :: forall a. Ord a => Sum a -> Sum a -> Bool
>= :: Sum a -> Sum a -> Bool
$cmax :: forall a. Ord a => Sum a -> Sum a -> Sum a
max :: Sum a -> Sum a -> Sum a
$cmin :: forall a. Ord a => Sum a -> Sum a -> Sum a
min :: Sum a -> Sum a -> Sum a
Ord, ReadPrec [Sum a]
ReadPrec (Sum a)
Int -> ReadS (Sum a)
ReadS [Sum a]
(Int -> ReadS (Sum a))
-> ReadS [Sum a]
-> ReadPrec (Sum a)
-> ReadPrec [Sum a]
-> Read (Sum a)
forall a. Read a => ReadPrec [Sum a]
forall a. Read a => ReadPrec (Sum a)
forall a. Read a => Int -> ReadS (Sum a)
forall a. Read a => ReadS [Sum a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Sum a)
readsPrec :: Int -> ReadS (Sum a)
$creadList :: forall a. Read a => ReadS [Sum a]
readList :: ReadS [Sum a]
$creadPrec :: forall a. Read a => ReadPrec (Sum a)
readPrec :: ReadPrec (Sum a)
$creadListPrec :: forall a. Read a => ReadPrec [Sum a]
readListPrec :: ReadPrec [Sum a]
Read, Int -> Sum a -> ShowS
[Sum a] -> ShowS
Sum a -> String
(Int -> Sum a -> ShowS)
-> (Sum a -> String) -> ([Sum a] -> ShowS) -> Show (Sum a)
forall a. Show a => Int -> Sum a -> ShowS
forall a. Show a => [Sum a] -> ShowS
forall a. Show a => Sum a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Sum a -> ShowS
showsPrec :: Int -> Sum a -> ShowS
$cshow :: forall a. Show a => Sum a -> String
show :: Sum a -> String
$cshowList :: forall a. Show a => [Sum a] -> ShowS
showList :: [Sum a] -> ShowS
Show,
        Sum a
Sum a -> Sum a -> Sum a
(Sum a -> Sum a -> Sum a)
-> Sum a
-> (forall b. ToInteger b => b -> Sum a -> Sum a)
-> AdditiveMonoid (Sum a)
forall b. ToInteger b => b -> Sum a -> Sum a
forall a. AdditiveMonoid a => Sum a
forall a. AdditiveMonoid a => Sum a -> Sum a -> Sum a
forall a b. (AdditiveMonoid a, ToInteger b) => b -> Sum a -> Sum a
forall a.
(a -> a -> a)
-> a -> (forall b. ToInteger b => b -> a -> a) -> AdditiveMonoid a
$c+ :: forall a. AdditiveMonoid a => Sum a -> Sum a -> Sum a
+ :: Sum a -> Sum a -> Sum a
$czero :: forall a. AdditiveMonoid a => Sum a
zero :: Sum a
$catimes :: forall a b. (AdditiveMonoid a, ToInteger b) => b -> Sum a -> Sum a
atimes :: forall b. ToInteger b => b -> Sum a -> Sum a
AdditiveMonoid, AdditiveMonoid (Sum a)
AdditiveMonoid (Sum a) =>
(Sum a -> Sum a -> Sum a)
-> (Sum a -> Sum a)
-> (forall b. (AbelianGroup b, ToInteger b) => b -> Sum a -> Sum a)
-> AbelianGroup (Sum a)
Sum a -> Sum a
Sum a -> Sum a -> Sum a
forall a. AbelianGroup a => AdditiveMonoid (Sum a)
forall b. (AbelianGroup b, ToInteger b) => b -> Sum a -> Sum a
forall a. AbelianGroup a => Sum a -> Sum a
forall a. AbelianGroup a => Sum a -> Sum a -> Sum a
forall a b.
(AbelianGroup a, AbelianGroup b, ToInteger b) =>
b -> Sum a -> Sum a
forall a.
AdditiveMonoid a =>
(a -> a -> a)
-> (a -> a)
-> (forall b. (AbelianGroup b, ToInteger b) => b -> a -> a)
-> AbelianGroup a
$c- :: forall a. AbelianGroup a => Sum a -> Sum a -> Sum a
- :: Sum a -> Sum a -> Sum a
$cnegate :: forall a. AbelianGroup a => Sum a -> Sum a
negate :: Sum a -> Sum a
$cgtimes :: forall a b.
(AbelianGroup a, AbelianGroup b, ToInteger b) =>
b -> Sum a -> Sum a
gtimes :: forall b. (AbelianGroup b, ToInteger b) => b -> Sum a -> Sum a
AbelianGroup, AdditiveMonoid (Sum a)
Sum a
Natural -> Sum a
AdditiveMonoid (Sum a) =>
(Sum a -> Sum a -> Sum a)
-> Sum a
-> (Natural -> Sum a)
-> (Sum a -> Sum a -> (Sum a, Sum a, Sum a -> Sum a))
-> Semiring (Sum a)
Sum a -> Sum a -> (Sum a, Sum a, Sum a -> Sum a)
Sum a -> Sum a -> Sum a
forall a. Semiring a => AdditiveMonoid (Sum a)
forall a. Semiring a => Sum a
forall a. Semiring a => Natural -> Sum a
forall a.
Semiring a =>
Sum a -> Sum a -> (Sum a, Sum a, Sum a -> Sum a)
forall a. Semiring a => Sum a -> Sum a -> Sum a
forall a.
AdditiveMonoid a =>
(a -> a -> a)
-> a -> (Natural -> a) -> (a -> a -> (a, a, a -> a)) -> Semiring a
$c* :: forall a. Semiring a => Sum a -> Sum a -> Sum a
* :: Sum a -> Sum a -> Sum a
$cone :: forall a. Semiring a => Sum a
one :: Sum a
$cfromNatural :: forall a. Semiring a => Natural -> Sum a
fromNatural :: Natural -> Sum a
$crescale :: forall a.
Semiring a =>
Sum a -> Sum a -> (Sum a, Sum a, Sum a -> Sum a)
rescale :: Sum a -> Sum a -> (Sum a, Sum a, Sum a -> Sum a)
Semiring, Ord (Sum a)
Semiring (Sum a)
(Ord (Sum a), Semiring (Sum a)) =>
(Sum a -> Rational) -> ToRational (Sum a)
Sum a -> Rational
forall a. (Ord a, Semiring a) => (a -> Rational) -> ToRational a
forall a. ToRational a => Ord (Sum a)
forall a. ToRational a => Semiring (Sum a)
forall a. ToRational a => Sum a -> Rational
$ctoRational :: forall a. ToRational a => Sum a -> Rational
toRational :: Sum a -> Rational
ToRational, Semiring (Sum a)
AbelianGroup (Sum a)
Integer -> Sum a
(AbelianGroup (Sum a), Semiring (Sum a)) =>
(Integer -> Sum a) -> Ring (Sum a)
forall a. Ring a => Semiring (Sum a)
forall a. Ring a => AbelianGroup (Sum a)
forall a. Ring a => Integer -> Sum a
forall a. (AbelianGroup a, Semiring a) => (Integer -> a) -> Ring a
$cfromInteger :: forall a. Ring a => Integer -> Sum a
fromInteger :: Integer -> Sum a
Ring,
        Ring (Sum a)
Ring (Sum a) => (Sum a -> Sum a) -> (Sum a -> Sum a) -> Num (Sum a)
Sum a -> Sum a
forall a. Num a => Ring (Sum a)
forall a. Num a => Sum a -> Sum a
forall a. Ring a => (a -> a) -> (a -> a) -> Num a
$cabs :: forall a. Num a => Sum a -> Sum a
abs :: Sum a -> Sum a
$csignum :: forall a. Num a => Sum a -> Sum a
signum :: Sum a -> Sum a
Num,
        Typeable (Sum a)
Typeable (Sum a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sum a -> c (Sum a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Sum a))
-> (Sum a -> Constr)
-> (Sum a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Sum a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)))
-> ((forall b. Data b => b -> b) -> Sum a -> Sum a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sum a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sum a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sum a -> m (Sum a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sum a -> m (Sum a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sum a -> m (Sum a))
-> Data (Sum a)
Sum a -> Constr
Sum a -> DataType
(forall b. Data b => b -> b) -> Sum a -> Sum a
forall a. Data a => Typeable (Sum a)
forall a. Data a => Sum a -> Constr
forall a. Data a => Sum a -> DataType
forall a. Data a => (forall b. Data b => b -> b) -> Sum a -> Sum a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Sum a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Sum a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sum a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sum a -> c (Sum a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sum a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Sum a -> u
forall u. (forall d. Data d => d -> u) -> Sum a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sum a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sum a -> c (Sum a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Sum a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sum a -> c (Sum a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sum a -> c (Sum a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sum a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Sum a)
$ctoConstr :: forall a. Data a => Sum a -> Constr
toConstr :: Sum a -> Constr
$cdataTypeOf :: forall a. Data a => Sum a -> DataType
dataTypeOf :: Sum a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Sum a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Sum a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a))
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Sum a -> Sum a
gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Sum a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Sum a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Sum a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sum a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sum a -> m (Sum a)
Data, (forall x. Sum a -> Rep (Sum a) x)
-> (forall x. Rep (Sum a) x -> Sum a) -> Generic (Sum a)
forall x. Rep (Sum a) x -> Sum a
forall x. Sum a -> Rep (Sum a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Sum a) x -> Sum a
forall a x. Sum a -> Rep (Sum a) x
$cfrom :: forall a x. Sum a -> Rep (Sum a) x
from :: forall x. Sum a -> Rep (Sum a) x
$cto :: forall a x. Rep (Sum a) x -> Sum a
to :: forall x. Rep (Sum a) x -> Sum a
Generic, (forall a. Sum a -> Rep1 Sum a)
-> (forall a. Rep1 Sum a -> Sum a) -> Generic1 Sum
forall a. Rep1 Sum a -> Sum a
forall a. Sum a -> Rep1 Sum a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Sum a -> Rep1 Sum a
from1 :: forall a. Sum a -> Rep1 Sum a
$cto1 :: forall a. Rep1 Sum a -> Sum a
to1 :: forall a. Rep1 Sum a -> Sum a
Generic1, (forall a b. (a -> b) -> Sum a -> Sum b)
-> (forall a b. a -> Sum b -> Sum a) -> Functor Sum
forall a b. a -> Sum b -> Sum a
forall a b. (a -> b) -> Sum a -> Sum b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Sum a -> Sum b
fmap :: forall a b. (a -> b) -> Sum a -> Sum b
$c<$ :: forall a b. a -> Sum b -> Sum a
<$ :: forall a b. a -> Sum b -> Sum a
Functor, (forall m. Monoid m => Sum m -> m)
-> (forall m a. Monoid m => (a -> m) -> Sum a -> m)
-> (forall m a. Monoid m => (a -> m) -> Sum a -> m)
-> (forall a b. (a -> b -> b) -> b -> Sum a -> b)
-> (forall a b. (a -> b -> b) -> b -> Sum a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sum a -> b)
-> (forall b a. (b -> a -> b) -> b -> Sum a -> b)
-> (forall a. (a -> a -> a) -> Sum a -> a)
-> (forall a. (a -> a -> a) -> Sum a -> a)
-> (forall a. Sum a -> [a])
-> (forall a. Sum a -> Bool)
-> (forall a. Sum a -> Int)
-> (forall a. Eq a => a -> Sum a -> Bool)
-> (forall a. Ord a => Sum a -> a)
-> (forall a. Ord a => Sum a -> a)
-> (forall a. Num a => Sum a -> a)
-> (forall a. Num a => Sum a -> a)
-> Foldable Sum
forall a. Eq a => a -> Sum a -> Bool
forall a. Num a => Sum a -> a
forall a. Ord a => Sum a -> a
forall m. Monoid m => Sum m -> m
forall a. Sum a -> Bool
forall a. Sum a -> Int
forall a. Sum a -> [a]
forall a. (a -> a -> a) -> Sum a -> a
forall m a. Monoid m => (a -> m) -> Sum a -> m
forall b a. (b -> a -> b) -> b -> Sum a -> b
forall a b. (a -> b -> b) -> b -> Sum a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Sum m -> m
fold :: forall m. Monoid m => Sum m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Sum a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Sum a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Sum a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Sum a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Sum a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Sum a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Sum a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Sum a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Sum a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Sum a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Sum a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Sum a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Sum a -> a
foldr1 :: forall a. (a -> a -> a) -> Sum a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Sum a -> a
foldl1 :: forall a. (a -> a -> a) -> Sum a -> a
$ctoList :: forall a. Sum a -> [a]
toList :: forall a. Sum a -> [a]
$cnull :: forall a. Sum a -> Bool
null :: forall a. Sum a -> Bool
$clength :: forall a. Sum a -> Int
length :: forall a. Sum a -> Int
$celem :: forall a. Eq a => a -> Sum a -> Bool
elem :: forall a. Eq a => a -> Sum a -> Bool
$cmaximum :: forall a. Ord a => Sum a -> a
maximum :: forall a. Ord a => Sum a -> a
$cminimum :: forall a. Ord a => Sum a -> a
minimum :: forall a. Ord a => Sum a -> a
$csum :: forall a. Num a => Sum a -> a
sum :: forall a. Num a => Sum a -> a
$cproduct :: forall a. Num a => Sum a -> a
product :: forall a. Num a => Sum a -> a
Foldable, Functor Sum
Foldable Sum
(Functor Sum, Foldable Sum) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Sum a -> f (Sum b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Sum (f a) -> f (Sum a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Sum a -> m (Sum b))
-> (forall (m :: * -> *) a. Monad m => Sum (m a) -> m (Sum a))
-> Traversable Sum
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Sum (m a) -> m (Sum a)
forall (f :: * -> *) a. Applicative f => Sum (f a) -> f (Sum a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sum a -> m (Sum b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sum a -> f (Sum b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sum a -> f (Sum b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Sum a -> f (Sum b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Sum (f a) -> f (Sum a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Sum (f a) -> f (Sum a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sum a -> m (Sum b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Sum a -> m (Sum b)
$csequence :: forall (m :: * -> *) a. Monad m => Sum (m a) -> m (Sum a)
sequence :: forall (m :: * -> *) a. Monad m => Sum (m a) -> m (Sum a)
Traversable)
 
instance (AdditiveMonoid a) => Semigroup (Sum a) where
    Sum a
x <> :: Sum a -> Sum a -> Sum a
<> Sum a
y = a -> Sum a
forall a. a -> Sum a
Sum (a
x a -> a -> a
forall a. AdditiveMonoid a => a -> a -> a
+ a
y)

instance (AdditiveMonoid a) => Monoid (Sum a) where
    mempty :: Sum a
mempty = a -> Sum a
forall a. a -> Sum a
Sum a
forall a. AdditiveMonoid a => a
zero

instance Applicative Sum where
    pure :: forall a. a -> Sum a
pure a
x = a -> Sum a
forall a. a -> Sum a
Sum a
x
    Sum a -> b
f <*> :: forall a b. Sum (a -> b) -> Sum a -> Sum b
<*> Sum a
x = b -> Sum b
forall a. a -> Sum a
Sum (a -> b
f a
x)

instance Monad Sum where
    Sum a
x >>= :: forall a b. Sum a -> (a -> Sum b) -> Sum b
>>= a -> Sum b
f = a -> Sum b
f a
x

-- | A redefinition of the @Product@ adaptor from "Data.Semigroup" with
-- more general instances.
newtype Product a = Product a
    deriving (Product a
Product a -> Product a -> Bounded (Product a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Product a
$cminBound :: forall a. Bounded a => Product a
minBound :: Product a
$cmaxBound :: forall a. Bounded a => Product a
maxBound :: Product a
Bounded, Product a -> Product a -> Bool
(Product a -> Product a -> Bool)
-> (Product a -> Product a -> Bool) -> Eq (Product a)
forall a. Eq a => Product a -> Product a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Product a -> Product a -> Bool
== :: Product a -> Product a -> Bool
$c/= :: forall a. Eq a => Product a -> Product a -> Bool
/= :: Product a -> Product a -> Bool
Eq, Eq (Product a)
Eq (Product a) =>
(Product a -> Product a -> Ordering)
-> (Product a -> Product a -> Bool)
-> (Product a -> Product a -> Bool)
-> (Product a -> Product a -> Bool)
-> (Product a -> Product a -> Bool)
-> (Product a -> Product a -> Product a)
-> (Product a -> Product a -> Product a)
-> Ord (Product a)
Product a -> Product a -> Bool
Product a -> Product a -> Ordering
Product a -> Product a -> Product a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Product a)
forall a. Ord a => Product a -> Product a -> Bool
forall a. Ord a => Product a -> Product a -> Ordering
forall a. Ord a => Product a -> Product a -> Product a
$ccompare :: forall a. Ord a => Product a -> Product a -> Ordering
compare :: Product a -> Product a -> Ordering
$c< :: forall a. Ord a => Product a -> Product a -> Bool
< :: Product a -> Product a -> Bool
$c<= :: forall a. Ord a => Product a -> Product a -> Bool
<= :: Product a -> Product a -> Bool
$c> :: forall a. Ord a => Product a -> Product a -> Bool
> :: Product a -> Product a -> Bool
$c>= :: forall a. Ord a => Product a -> Product a -> Bool
>= :: Product a -> Product a -> Bool
$cmax :: forall a. Ord a => Product a -> Product a -> Product a
max :: Product a -> Product a -> Product a
$cmin :: forall a. Ord a => Product a -> Product a -> Product a
min :: Product a -> Product a -> Product a
Ord, ReadPrec [Product a]
ReadPrec (Product a)
Int -> ReadS (Product a)
ReadS [Product a]
(Int -> ReadS (Product a))
-> ReadS [Product a]
-> ReadPrec (Product a)
-> ReadPrec [Product a]
-> Read (Product a)
forall a. Read a => ReadPrec [Product a]
forall a. Read a => ReadPrec (Product a)
forall a. Read a => Int -> ReadS (Product a)
forall a. Read a => ReadS [Product a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Product a)
readsPrec :: Int -> ReadS (Product a)
$creadList :: forall a. Read a => ReadS [Product a]
readList :: ReadS [Product a]
$creadPrec :: forall a. Read a => ReadPrec (Product a)
readPrec :: ReadPrec (Product a)
$creadListPrec :: forall a. Read a => ReadPrec [Product a]
readListPrec :: ReadPrec [Product a]
Read, Int -> Product a -> ShowS
[Product a] -> ShowS
Product a -> String
(Int -> Product a -> ShowS)
-> (Product a -> String)
-> ([Product a] -> ShowS)
-> Show (Product a)
forall a. Show a => Int -> Product a -> ShowS
forall a. Show a => [Product a] -> ShowS
forall a. Show a => Product a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Product a -> ShowS
showsPrec :: Int -> Product a -> ShowS
$cshow :: forall a. Show a => Product a -> String
show :: Product a -> String
$cshowList :: forall a. Show a => [Product a] -> ShowS
showList :: [Product a] -> ShowS
Show,
        Product a
Product a -> Product a -> Product a
(Product a -> Product a -> Product a)
-> Product a
-> (forall b. ToInteger b => b -> Product a -> Product a)
-> AdditiveMonoid (Product a)
forall b. ToInteger b => b -> Product a -> Product a
forall a. AdditiveMonoid a => Product a
forall a. AdditiveMonoid a => Product a -> Product a -> Product a
forall a b.
(AdditiveMonoid a, ToInteger b) =>
b -> Product a -> Product a
forall a.
(a -> a -> a)
-> a -> (forall b. ToInteger b => b -> a -> a) -> AdditiveMonoid a
$c+ :: forall a. AdditiveMonoid a => Product a -> Product a -> Product a
+ :: Product a -> Product a -> Product a
$czero :: forall a. AdditiveMonoid a => Product a
zero :: Product a
$catimes :: forall a b.
(AdditiveMonoid a, ToInteger b) =>
b -> Product a -> Product a
atimes :: forall b. ToInteger b => b -> Product a -> Product a
AdditiveMonoid, AdditiveMonoid (Product a)
AdditiveMonoid (Product a) =>
(Product a -> Product a -> Product a)
-> (Product a -> Product a)
-> (forall b.
    (AbelianGroup b, ToInteger b) =>
    b -> Product a -> Product a)
-> AbelianGroup (Product a)
Product a -> Product a
Product a -> Product a -> Product a
forall a. AbelianGroup a => AdditiveMonoid (Product a)
forall b.
(AbelianGroup b, ToInteger b) =>
b -> Product a -> Product a
forall a. AbelianGroup a => Product a -> Product a
forall a. AbelianGroup a => Product a -> Product a -> Product a
forall a b.
(AbelianGroup a, AbelianGroup b, ToInteger b) =>
b -> Product a -> Product a
forall a.
AdditiveMonoid a =>
(a -> a -> a)
-> (a -> a)
-> (forall b. (AbelianGroup b, ToInteger b) => b -> a -> a)
-> AbelianGroup a
$c- :: forall a. AbelianGroup a => Product a -> Product a -> Product a
- :: Product a -> Product a -> Product a
$cnegate :: forall a. AbelianGroup a => Product a -> Product a
negate :: Product a -> Product a
$cgtimes :: forall a b.
(AbelianGroup a, AbelianGroup b, ToInteger b) =>
b -> Product a -> Product a
gtimes :: forall b.
(AbelianGroup b, ToInteger b) =>
b -> Product a -> Product a
AbelianGroup, AdditiveMonoid (Product a)
Product a
Natural -> Product a
AdditiveMonoid (Product a) =>
(Product a -> Product a -> Product a)
-> Product a
-> (Natural -> Product a)
-> (Product a
    -> Product a -> (Product a, Product a, Product a -> Product a))
-> Semiring (Product a)
Product a
-> Product a -> (Product a, Product a, Product a -> Product a)
Product a -> Product a -> Product a
forall a. Semiring a => AdditiveMonoid (Product a)
forall a. Semiring a => Product a
forall a. Semiring a => Natural -> Product a
forall a.
Semiring a =>
Product a
-> Product a -> (Product a, Product a, Product a -> Product a)
forall a. Semiring a => Product a -> Product a -> Product a
forall a.
AdditiveMonoid a =>
(a -> a -> a)
-> a -> (Natural -> a) -> (a -> a -> (a, a, a -> a)) -> Semiring a
$c* :: forall a. Semiring a => Product a -> Product a -> Product a
* :: Product a -> Product a -> Product a
$cone :: forall a. Semiring a => Product a
one :: Product a
$cfromNatural :: forall a. Semiring a => Natural -> Product a
fromNatural :: Natural -> Product a
$crescale :: forall a.
Semiring a =>
Product a
-> Product a -> (Product a, Product a, Product a -> Product a)
rescale :: Product a
-> Product a -> (Product a, Product a, Product a -> Product a)
Semiring, Ord (Product a)
Semiring (Product a)
(Ord (Product a), Semiring (Product a)) =>
(Product a -> Rational) -> ToRational (Product a)
Product a -> Rational
forall a. (Ord a, Semiring a) => (a -> Rational) -> ToRational a
forall a. ToRational a => Ord (Product a)
forall a. ToRational a => Semiring (Product a)
forall a. ToRational a => Product a -> Rational
$ctoRational :: forall a. ToRational a => Product a -> Rational
toRational :: Product a -> Rational
ToRational, Semiring (Product a)
AbelianGroup (Product a)
Integer -> Product a
(AbelianGroup (Product a), Semiring (Product a)) =>
(Integer -> Product a) -> Ring (Product a)
forall a. Ring a => Semiring (Product a)
forall a. Ring a => AbelianGroup (Product a)
forall a. Ring a => Integer -> Product a
forall a. (AbelianGroup a, Semiring a) => (Integer -> a) -> Ring a
$cfromInteger :: forall a. Ring a => Integer -> Product a
fromInteger :: Integer -> Product a
Ring,
        Ring (Product a)
Ring (Product a) =>
(Product a -> Product a)
-> (Product a -> Product a) -> Num (Product a)
Product a -> Product a
forall a. Num a => Ring (Product a)
forall a. Num a => Product a -> Product a
forall a. Ring a => (a -> a) -> (a -> a) -> Num a
$cabs :: forall a. Num a => Product a -> Product a
abs :: Product a -> Product a
$csignum :: forall a. Num a => Product a -> Product a
signum :: Product a -> Product a
Num,
        Typeable (Product a)
Typeable (Product a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Product a -> c (Product a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Product a))
-> (Product a -> Constr)
-> (Product a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Product a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Product a)))
-> ((forall b. Data b => b -> b) -> Product a -> Product a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Product a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Product a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Product a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Product a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Product a -> m (Product a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Product a -> m (Product a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Product a -> m (Product a))
-> Data (Product a)
Product a -> Constr
Product a -> DataType
(forall b. Data b => b -> b) -> Product a -> Product a
forall a. Data a => Typeable (Product a)
forall a. Data a => Product a -> Constr
forall a. Data a => Product a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Product a -> Product a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Product a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Product a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Product a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Product a -> c (Product a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Product a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Product a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Product a -> u
forall u. (forall d. Data d => d -> u) -> Product a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Product a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Product a -> c (Product a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Product a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Product a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Product a -> c (Product a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Product a -> c (Product a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Product a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Product a)
$ctoConstr :: forall a. Data a => Product a -> Constr
toConstr :: Product a -> Constr
$cdataTypeOf :: forall a. Data a => Product a -> DataType
dataTypeOf :: Product a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Product a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Product a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Product a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Product a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Product a -> Product a
gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Product a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Product a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Product a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Product a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Product a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Product a -> m (Product a)
Data, (forall x. Product a -> Rep (Product a) x)
-> (forall x. Rep (Product a) x -> Product a)
-> Generic (Product a)
forall x. Rep (Product a) x -> Product a
forall x. Product a -> Rep (Product a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Product a) x -> Product a
forall a x. Product a -> Rep (Product a) x
$cfrom :: forall a x. Product a -> Rep (Product a) x
from :: forall x. Product a -> Rep (Product a) x
$cto :: forall a x. Rep (Product a) x -> Product a
to :: forall x. Rep (Product a) x -> Product a
Generic, (forall a. Product a -> Rep1 Product a)
-> (forall a. Rep1 Product a -> Product a) -> Generic1 Product
forall a. Rep1 Product a -> Product a
forall a. Product a -> Rep1 Product a
forall k (f :: k -> *).
(forall (a :: k). f a -> Rep1 f a)
-> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
$cfrom1 :: forall a. Product a -> Rep1 Product a
from1 :: forall a. Product a -> Rep1 Product a
$cto1 :: forall a. Rep1 Product a -> Product a
to1 :: forall a. Rep1 Product a -> Product a
Generic1, (forall a b. (a -> b) -> Product a -> Product b)
-> (forall a b. a -> Product b -> Product a) -> Functor Product
forall a b. a -> Product b -> Product a
forall a b. (a -> b) -> Product a -> Product b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Product a -> Product b
fmap :: forall a b. (a -> b) -> Product a -> Product b
$c<$ :: forall a b. a -> Product b -> Product a
<$ :: forall a b. a -> Product b -> Product a
Functor, (forall m. Monoid m => Product m -> m)
-> (forall m a. Monoid m => (a -> m) -> Product a -> m)
-> (forall m a. Monoid m => (a -> m) -> Product a -> m)
-> (forall a b. (a -> b -> b) -> b -> Product a -> b)
-> (forall a b. (a -> b -> b) -> b -> Product a -> b)
-> (forall b a. (b -> a -> b) -> b -> Product a -> b)
-> (forall b a. (b -> a -> b) -> b -> Product a -> b)
-> (forall a. (a -> a -> a) -> Product a -> a)
-> (forall a. (a -> a -> a) -> Product a -> a)
-> (forall a. Product a -> [a])
-> (forall a. Product a -> Bool)
-> (forall a. Product a -> Int)
-> (forall a. Eq a => a -> Product a -> Bool)
-> (forall a. Ord a => Product a -> a)
-> (forall a. Ord a => Product a -> a)
-> (forall a. Num a => Product a -> a)
-> (forall a. Num a => Product a -> a)
-> Foldable Product
forall a. Eq a => a -> Product a -> Bool
forall a. Num a => Product a -> a
forall a. Ord a => Product a -> a
forall m. Monoid m => Product m -> m
forall a. Product a -> Bool
forall a. Product a -> Int
forall a. Product a -> [a]
forall a. (a -> a -> a) -> Product a -> a
forall m a. Monoid m => (a -> m) -> Product a -> m
forall b a. (b -> a -> b) -> b -> Product a -> b
forall a b. (a -> b -> b) -> b -> Product a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Product m -> m
fold :: forall m. Monoid m => Product m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Product a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Product a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Product a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Product a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Product a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Product a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Product a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Product a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Product a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Product a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Product a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Product a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Product a -> a
foldr1 :: forall a. (a -> a -> a) -> Product a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Product a -> a
foldl1 :: forall a. (a -> a -> a) -> Product a -> a
$ctoList :: forall a. Product a -> [a]
toList :: forall a. Product a -> [a]
$cnull :: forall a. Product a -> Bool
null :: forall a. Product a -> Bool
$clength :: forall a. Product a -> Int
length :: forall a. Product a -> Int
$celem :: forall a. Eq a => a -> Product a -> Bool
elem :: forall a. Eq a => a -> Product a -> Bool
$cmaximum :: forall a. Ord a => Product a -> a
maximum :: forall a. Ord a => Product a -> a
$cminimum :: forall a. Ord a => Product a -> a
minimum :: forall a. Ord a => Product a -> a
$csum :: forall a. Num a => Product a -> a
sum :: forall a. Num a => Product a -> a
$cproduct :: forall a. Num a => Product a -> a
product :: forall a. Num a => Product a -> a
Foldable, Functor Product
Foldable Product
(Functor Product, Foldable Product) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Product a -> f (Product b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Product (f a) -> f (Product a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Product a -> m (Product b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Product (m a) -> m (Product a))
-> Traversable Product
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Product (m a) -> m (Product a)
forall (f :: * -> *) a.
Applicative f =>
Product (f a) -> f (Product a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Product a -> m (Product b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Product a -> f (Product b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Product a -> f (Product b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Product a -> f (Product b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Product (f a) -> f (Product a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Product (f a) -> f (Product a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Product a -> m (Product b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Product a -> m (Product b)
$csequence :: forall (m :: * -> *) a. Monad m => Product (m a) -> m (Product a)
sequence :: forall (m :: * -> *) a. Monad m => Product (m a) -> m (Product a)
Traversable)
 
instance (Semiring a) => Semigroup (Product a) where
    Product a
x <> :: Product a -> Product a -> Product a
<> Product a
y = a -> Product a
forall a. a -> Product a
Product (a
x a -> a -> a
forall a. Semiring a => a -> a -> a
* a
y)

instance (Semiring a) => Monoid (Product a) where
    mempty :: Product a
mempty = a -> Product a
forall a. a -> Product a
Product a
forall a. Semiring a => a
one

instance Applicative Product where
    pure :: forall a. a -> Product a
pure a
x = a -> Product a
forall a. a -> Product a
Product a
x
    Product a -> b
f <*> :: forall a b. Product (a -> b) -> Product a -> Product b
<*> Product a
x = b -> Product b
forall a. a -> Product a
Product (a -> b
f a
x)

instance Monad Product where
    Product a
x >>= :: forall a b. Product a -> (a -> Product b) -> Product b
>>= a -> Product b
f = a -> Product b
f a
x