, LogInterval(..)

data LogInterval = LogInterval 
  { intervalBtcAddr :: BtcAddr
  , workInterval :: Interval
  } deriving (Show, Eq) 

      let testAddrs = L.fromList $ catMaybes 

      let testAddrs = catMaybes 

          starts = L.fromList $ toThyme <$> catMaybes 

          starts = toThyme <$> catMaybes 

          ends   = L.fromList $ toThyme <$> catMaybes 

          ends   = toThyme <$> catMaybes 

          testIntervals :: NonEmpty LogInterval

          testIntervals :: [(BtcAddr, Interval)]

            (start', end') <- L.zip starts ends
            pure $ LogInterval addr (I.interval start' end')

            (start', end') <- ClassyPrelude.zip starts ends
            pure $ (addr, I.interval start' end')

          testLogEntries :: NonEmpty LogEntry

          testLogEntries :: [LogEntry]

            (LogInterval addr (Interval start' end')) <- testIntervals
            L.fromList [ LogEntry addr (WorkEvent StartWork start' Nothing)
                       , LogEntry addr (WorkEvent StopWork end' Nothing) ]

            (addr, Interval start' end') <- testIntervals
            LogEntry addr <$> [WorkEvent StartWork start' Nothing, WorkEvent StopWork end' Nothing]

          expected' = fromListWith (<>) . L.toList $ (intervalBtcAddr &&& pure . workInterval) <$> testIntervals
          expected :: WorkIndex
          expected = WorkIndex $ fmap (L.reverse . L.sort) expected'

          expected' = fromListWith (<>) $ fmap (second pure) testIntervals
          expected  = WorkIndex $ fmap (L.reverse . L.sort) expected'