Пример из лекции (Haskell)

quotes.csv

stockdata.hs

{-# LANGUAGE OverloadedStrings, DeriveGeneric
             , TypeSynonymInstances, FlexibleInstances
             , RecordWildCards #-}
module Main where

import qualified Data.ByteString.Lazy as BL
import Data.ByteString.Char8 (unpack)
import qualified Data.Vector as V
import System.Environment
import Data.Csv
import Data.Time.Calendar
import Data.Time.Format
import Data.Ord
import Data.List
import Data.Number.Fixed
import GHC.Generics (Generic)
import Options.Applicative as Opt
import Data.Semigroup ((<>))
import Control.Monad

type Eps4 = EpsDiv10 (EpsDiv10 (EpsDiv10 (EpsDiv10 Eps1)))
type Fixed4 = Fixed Eps4

data QuoteData = QD {
                  day :: Day,
                  close :: Fixed4,
                  volume :: Fixed4,
                  open :: Fixed4,
                  high :: Fixed4,
                  low :: Fixed4
                 }
                 deriving (Generic, Show)

instance FromField Fixed4 where
  parseField s = return (read $ unpack s)
  
instance FromField Day where
  parseField s = parseTimeM False defaultTimeLocale "%Y/%m/%d" (unpack s)
  
instance FromNamedRecord QuoteData
instance DefaultOrdered QuoteData


mean v = sum v / (fromIntegral $ length v)

daysBetweenMinMax qf quotes = abs $ diffDays (day minCloseQuote)
                                               (day maxCloseQuote)
  where
    minCloseQuote = minimumBy (comparing (f2fun qf)) quotes
    maxCloseQuote = maximumBy (comparing (f2fun qf)) quotes



data Operation = Mean | Min | Max

instance Show Operation where
  show Mean = "mean"
  show Min = "minimum"
  show Max = "maximum"

op2fun :: (Foldable t, Fractional a, Ord a) => Operation -> t a -> a
op2fun Mean = mean
op2fun Min = minimum
op2fun Max = maximum


data QField = Op | Cl | High | Low | Vol

instance Show QField where
  show Op = "open"
  show Cl = "close"
  show Vol = "volume"
  show High = "high"
  show Low = "low"

f2fun :: QField -> QuoteData -> Fixed4
f2fun Op = open
f2fun Cl = close
f2fun Vol = volume
f2fun High = high
f2fun Low = low


computeStatistics :: Operation -> QField -> V.Vector QuoteData -> Fixed4
computeStatistics op f v = op2fun op $ V.map (f2fun f) v


data Params = Params {
                fname :: String,
                daysBetween :: Bool,
                op :: Operation,
                qf :: QField
              }

params :: Opt.Parser Params
params = Params
      <$> strOption
          ( long "fname"
         <> short 'f'   
         <> help "File with quotes data" )
      <*> switch
          ( long "days"
         <> short 'd'
         <> help "Print number of days between min/max" )
      <*> subparser (
            metavar "STATISTIC" <> commandGroup "Available statistics:" <>
            command "mean" (Mean `withInfo` "Compute mean") <>
            command "min" (Min `withInfo` "Compute minimum") <>
            command "max" (Max `withInfo` "Compute maximum"))
      <*> subparser (
            metavar "FIELD" <> commandGroup "Available fields:" <>
            command "open" (Op `withInfo` "open") <>
            command "close" (Cl `withInfo` "close") <>
            command "low" (Low `withInfo` "low") <>
            command "high" (High `withInfo` "high")  <>
            command "volume" (Vol `withInfo` "volume"))
    where withInfo op str = info (pure op) (progDesc str)
           

work :: Params -> IO ()
work Params {..} = do
  csvData <- BL.readFile fname
  case decodeByName csvData of
    Left err -> putStrLn err
    Right (_, quotes) -> do
      when daysBetween $ do
        putStrLn $ "Days between min/max " ++ show qf ++ ":"
        print $ daysBetweenMinMax qf quotes
      putStrLn $ "Statistic: " ++ show op ++ " on " ++ show qf
      print $ computeStatistics op qf quotes
  
main :: IO ()
main = execParser opts  >>= work
  where
    opts = info (params <**> helper)
                ( fullDesc
                     <> progDesc "Print statistics on stock quotes data")