\subsection{Cardano.BM.Data.AggregatedKind}
\label{code:Cardano.BM.Data.AggregatedKind}

%if style == newcode
\begin{code}
{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}

module Cardano.BM.Data.AggregatedKind
  ( AggregatedKind (..)
  )
  where

import           Data.Aeson (FromJSON, ToJSON)
import           GHC.Generics (Generic)

\end{code}
%endif

\subsubsection{AggregatedKind}\label{code:AggregatedKind}\index{AggregatedKind}
\label{code:StatsAK}\index{AggregatedKind!StatsAK}
\label{code:EwmaAK}\index{AggregatedKind!EwmaAK}
This identifies the type of Aggregated.
\begin{code}
data AggregatedKind = StatsAK
                    | EwmaAK { AggregatedKind -> Double
alpha :: !Double }
                        deriving ((forall x. AggregatedKind -> Rep AggregatedKind x)
-> (forall x. Rep AggregatedKind x -> AggregatedKind)
-> Generic AggregatedKind
forall x. Rep AggregatedKind x -> AggregatedKind
forall x. AggregatedKind -> Rep AggregatedKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AggregatedKind x -> AggregatedKind
$cfrom :: forall x. AggregatedKind -> Rep AggregatedKind x
Generic, AggregatedKind -> AggregatedKind -> Bool
(AggregatedKind -> AggregatedKind -> Bool)
-> (AggregatedKind -> AggregatedKind -> Bool) -> Eq AggregatedKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AggregatedKind -> AggregatedKind -> Bool
$c/= :: AggregatedKind -> AggregatedKind -> Bool
== :: AggregatedKind -> AggregatedKind -> Bool
$c== :: AggregatedKind -> AggregatedKind -> Bool
Eq, Int -> AggregatedKind -> ShowS
[AggregatedKind] -> ShowS
AggregatedKind -> String
(Int -> AggregatedKind -> ShowS)
-> (AggregatedKind -> String)
-> ([AggregatedKind] -> ShowS)
-> Show AggregatedKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AggregatedKind] -> ShowS
$cshowList :: [AggregatedKind] -> ShowS
show :: AggregatedKind -> String
$cshow :: AggregatedKind -> String
showsPrec :: Int -> AggregatedKind -> ShowS
$cshowsPrec :: Int -> AggregatedKind -> ShowS
Show, Value -> Parser [AggregatedKind]
Value -> Parser AggregatedKind
(Value -> Parser AggregatedKind)
-> (Value -> Parser [AggregatedKind]) -> FromJSON AggregatedKind
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [AggregatedKind]
$cparseJSONList :: Value -> Parser [AggregatedKind]
parseJSON :: Value -> Parser AggregatedKind
$cparseJSON :: Value -> Parser AggregatedKind
FromJSON, [AggregatedKind] -> Encoding
[AggregatedKind] -> Value
AggregatedKind -> Encoding
AggregatedKind -> Value
(AggregatedKind -> Value)
-> (AggregatedKind -> Encoding)
-> ([AggregatedKind] -> Value)
-> ([AggregatedKind] -> Encoding)
-> ToJSON AggregatedKind
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [AggregatedKind] -> Encoding
$ctoEncodingList :: [AggregatedKind] -> Encoding
toJSONList :: [AggregatedKind] -> Value
$ctoJSONList :: [AggregatedKind] -> Value
toEncoding :: AggregatedKind -> Encoding
$ctoEncoding :: AggregatedKind -> Encoding
toJSON :: AggregatedKind -> Value
$ctoJSON :: AggregatedKind -> Value
ToJSON, ReadPrec [AggregatedKind]
ReadPrec AggregatedKind
Int -> ReadS AggregatedKind
ReadS [AggregatedKind]
(Int -> ReadS AggregatedKind)
-> ReadS [AggregatedKind]
-> ReadPrec AggregatedKind
-> ReadPrec [AggregatedKind]
-> Read AggregatedKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AggregatedKind]
$creadListPrec :: ReadPrec [AggregatedKind]
readPrec :: ReadPrec AggregatedKind
$creadPrec :: ReadPrec AggregatedKind
readList :: ReadS [AggregatedKind]
$creadList :: ReadS [AggregatedKind]
readsPrec :: Int -> ReadS AggregatedKind
$creadsPrec :: Int -> ReadS AggregatedKind
Read)

\end{code}