Update

Author: Russoul

timeseries-io/src/Cardano/Timeseries/Domain/Instant.hs

@@ -8,10 +8,10 @@ data Instant a = Instant {
   labels :: SeriesIdentifier,
   timestamp :: Timestamp,
   value :: a
-} deriving (Show, Eq, Functor)
+} deriving (Show, Eq, Functor, Foldable, Traversable)
 
 -- | Do the instant vectors share a series?
-share :: Instant a -> Instant a -> Bool
+share :: Instant a -> Instant b -> Bool
 share a b = labels a == labels b
 
 type InstantVector a = [Instant a]

timeseries-io/src/Cardano/Timeseries/Domain/Timeseries.hs

@@ -1,11 +1,13 @@
 {-# OPTIONS_GHC -Wno-name-shadowing #-}
-module Cardano.Timeseries.Domain.Timeseries(Timeseries(..), TimeseriesVector, transpose, toVector) where
+{-# LANGUAGE RecordWildCards #-}
+module Cardano.Timeseries.Domain.Timeseries(Timeseries(..), TimeseriesVector,
+  transpose, toVector, oldest, newest, eachOldest, eachNewest) where
 
-import           Cardano.Timeseries.Domain.Instant (InstantVector)
+import           Cardano.Timeseries.Domain.Instant (InstantVector, Instant (Instant))
 import qualified Cardano.Timeseries.Domain.Instant as Instant
 import           Cardano.Timeseries.Domain.Types
 
-import           Data.List (find)
+import           Data.List (find, maximumBy, minimumBy)
 import           Data.Set
 import qualified Data.Set as Set
 import           Data.Vector (Vector)
@@ -14,12 +16,29 @@ import qualified Data.Vector as Vector
 data Timeseries a = Timeseries {
   labels :: SeriesIdentifier,
   dat :: [(Timestamp, a)]
-}
+} deriving (Show, Functor, Foldable, Traversable)
+
+oldest :: Timeseries a -> Maybe (Instant a)
+oldest Timeseries{..} | Prelude.null dat = Nothing
+oldest Timeseries{..} =
+  let (t, x) = minimumBy (\(x, _) (y, _) -> compare x y) dat in
+  Just (Instant labels t x)
+
+newest :: Timeseries a -> Maybe (Instant a)
+newest Timeseries{..} | Prelude.null dat = Nothing
+newest Timeseries{..} =
+  let (t, x) = maximumBy (\(x, _) (y, _) -> compare x y) dat in
+  Just (Instant labels t x)
 
 -- | Every two elements in the list must have distinct series identifiers (set of labels),
 -- | i.e. the series in the list must be distinct.
 type TimeseriesVector a = [Timeseries a]
 
+eachOldest :: TimeseriesVector a -> Maybe [Instant a]
+eachOldest = traverse oldest
+
+eachNewest :: TimeseriesVector a -> Maybe [Instant a]
+eachNewest = traverse newest
 
 -- | Given a list of range vectors, forms up a timeseries vector.
 -- | This operation is, in some sense, transposition:
@@ -44,27 +63,27 @@ type TimeseriesVector a = [Timeseries a]
 -- |
 -- | ----------------------------------------> t
 --                     t₀ t₁ t₂ t₃
-transpose :: [InstantVector Double] -> TimeseriesVector Double
+transpose :: [InstantVector a] -> TimeseriesVector a
 transpose instants =
   Set.foldl' (\vector ls -> form ls instants : vector) [] (setOfLabels instants) where
 
   -- | Given a set of labels (identifying a series) form up a series from a list of instant vectors.
-  form :: SeriesIdentifier -> [InstantVector Double] -> Timeseries Double
+  form :: SeriesIdentifier -> [InstantVector a] -> Timeseries a
   form ls insts = Timeseries ls (form ls insts) where
     -- | Extract the data pertaining to the series (identified by the given `SeriesIdentifier`) from the list of
     -- | ranges vectors.
-    form :: SeriesIdentifier -> [InstantVector Double] -> [(Timestamp, Double)]
+    form :: SeriesIdentifier -> [InstantVector a] -> [(Timestamp, a)]
     form _ [] = []
     form ls (inst : insts) =
       case find (\i -> Instant.labels i == ls) inst of
         Just i -> (Instant.timestamp i, Instant.value i) : form ls insts
         Nothing -> form ls insts
 
-  setOfLabels' :: InstantVector Double -> Set SeriesIdentifier
+  setOfLabels' :: InstantVector a -> Set SeriesIdentifier
   setOfLabels' [] = Set.empty
   setOfLabels' (i : is) = Set.insert (Instant.labels i) (setOfLabels' is)
 
-  setOfLabels :: [InstantVector Double] -> Set SeriesIdentifier
+  setOfLabels :: [InstantVector a] -> Set SeriesIdentifier
   setOfLabels [] = Set.empty
   setOfLabels (v : vs) = setOfLabels' v `Set.union` setOfLabels vs