view,
    view',

import Data.Foldable

view :: DiffR a -> Text
view = unDiffR
view' :: (Traversable t) => t (DiffR (DeckRep DiffR) -> DiffR (DeckRep DiffR)) -> DeckRep DiffR
view' = unDiffR . foldl' (\acc f -> f acc) (deck mempty)

{-# LANGUAGE ExplicitForAll #-}

    readDiffFiles,

import Control.Concurrent
import Control.Concurrent.Async

import Data.Map (Map)

import Repr.StateRep

    -> IO (Either [ReadError] [repr (DeckRep repr) -> repr (DeckRep repr)])

    -> IO (Either [ReadError] [DiffSig repr])

readDiffFiles :: FilePath -> FilePath -> IO (Either [ReadError] (Map Text Card, Map Text Card))
readDiffFiles oldFile newFile = do
    oldTask <- async (fmap evalMany <$> readDeckList oldFile)
    newTask <- async (fmap evalMany <$> readDeckList newFile)
    finished <- waitEither oldTask newTask
    case finished of
        Left (Left e) -> cancel newTask >> pure (Left e)
        Right (Left e) -> cancel oldTask >> pure (Left e)
        Left (Right x) -> do
            y <- wait newTask
            case y of
                Left e -> pure $ Left e
                Right n -> pure . Right $ (x, n)
        Right (Right x) -> do
            y <- wait oldTask
            case y of
                Left e -> pure $ Left e
                Right n -> pure . Right $ (n, x)

    DiffSig,

        async,

        mtg

        mtg,
        optparse-applicative,
        text,

import qualified Data.Text.IO as TIO
import Options.Applicative
import Deck.Diff
import Parser
import Repr.DiffRep
diffP :: Parser (String, String)
diffP = (,) <$> strArgument (metavar "OLDFILE") <*> strArgument (metavar "NEWFILE")
runParser :: IO (String, String)
runParser = execParser opts
  where
    opts = info (diffP <**> helper) fullDesc

  putStrLn "Hello, Haskell!"

    (oldFile, newFile) <- runParser
    res <- readDiffFiles oldFile newFile
    case res of
        Left e -> print e
        Right (old, new) ->
            do
                let diffDeck = diff old new
                TIO.putStrLn $ view' diffDeck
    return ()