{-# LANGUAGE TemplateHaskell #-}

-- | Data for testing prettychart.
module Prettychart.ExampleData
  ( getReturns,
    taker,
  )
where

import Chart.FlatParse
import Data.ByteString qualified as BS
import Data.ByteString.Char8 qualified as C
import Data.Time.Calendar
import FlatParse.Basic (Parser, Result (OK), char, runParser)

dayP :: Parser e Day
dayP :: forall e. Parser e Day
dayP = do
  Int
y <- forall e. Parser e Int
int
  ()
_ <- $(char '-')
  Int
m <- forall e. Parser e Int
int
  ()
_ <- $(char '-')
  Int
d <- forall e. Parser e Int
int
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Year -> Int -> Int -> Day
fromGregorian (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
y) Int
m Int
d

runParserError :: Parser e a -> BS.ByteString -> a
runParserError :: forall e a. Parser e a -> ByteString -> a
runParserError Parser e a
p ByteString
bs = case forall e a. Parser e a -> ByteString -> Result e a
runParser Parser e a
p ByteString
bs of
  OK a
r ByteString
_ -> a
r
  Result e a
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"uncaught flatparse error"

dayReturnP :: Parser e (Day, Double)
dayReturnP :: forall e. Parser e (Day, Double)
dayReturnP = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e. Parser e Day
dayP forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ($(char ',') forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall b e. Num b => Parser e b -> Parser e b
signed forall e. Parser e Double
double)

-- | Read and parse example data, which is daily stock market returns since 1980.
getReturns :: IO [(Day, Double)]
getReturns :: IO [(Day, Double)]
getReturns = do
  ByteString
bs <- [Char] -> IO ByteString
BS.readFile [Char]
"other/returns.csv"
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall e a. Parser e a -> ByteString -> a
runParserError forall e. Parser e (Day, Double)
dayReturnP forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> [ByteString]
C.lines ByteString
bs

-- | Take the last n of a list.
taker :: Int -> [a] -> [a]
taker :: forall a. Int -> [a] -> [a]
taker Int
n = forall a. [a] -> [a]
reverse forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
take Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
reverse