wgaffa/deck-delta - Change DN2F55HBRBTHQAJDU4GOOGAEAXH5MIFPQSPEK2NNAPDJPZOOFJFQC

Refactor code to reflect new api changes

Created by wgaffa on March 24, 2024

DN2F55HBRBTHQAJDU4GOOGAEAXH5MIFPQSPEK2NNAPDJPZOOFJFQC

Dependencies

In channels

main

Change contents

Insertion in src/StateRep.hs at line 1 [5.36]
[5.36]
[5.37]
```
{-# LANGUAGE AllowAmbiguousTypes #-}
```
Insertion in src/StateRep.hs at line 5 [5.36]
[5.147]
[5.147]
```
{-# LANGUAGE LambdaCase #-}
```
Replacement in src/StateRep.hs at line 9 [5.36]
B:BD[5.196] → [5.196:210]
```
    RDefault,
```
[5.196]
[5.210]
```
    -- * Types
```
Insertion in src/StateRep.hs at line 12 [5.36]
[5.230]
[5.230]
```
    -- * Selectors
```
Deletion in src/StateRep.hs at line 19 [5.36]
B:BD[5.263] → [5.263:291]
B:BD[5.291] → [6.0:25]
```
import Control.Monad.State
import Data.Either.Extra
```
Replacement in src/StateRep.hs at line 24 [5.36]
B:BD[5.392] → [5.392:407]
```
import Refined
```
[5.392]
[5.407]
```
import Control.Lens
```
Insertion in src/StateRep.hs at line 28 [5.36]
[5.432]
[5.432]
```
import Util
```

Deletion in src/StateRep.hs at line 31 [5.36]

B:BD[5.462] → [5.462:566]

type RDefault = R (State CardMap)
newtype R m a = R {unR :: m a} deriving (Functor, Applicative, Monad)

Replacement in src/StateRep.hs at line 32 [5.36]

B:BD[5.567] → [5.567:711]

instance DeckSYM (R (State CardMap)) where
    add x = R $ do
        deck <- get
        put $ Map.insert (unrefine . runText $ name x) x deck

[5.567]

[5.711]

newtype R a = R {unR :: a} deriving (Show, Functor)

Replacement in src/StateRep.hs at line 34 [5.36]

B:BD[5.712] → [5.712:823]

    remove cardName = R $ do
        deck <- get
        put $ Map.delete (unrefine . runText $ cardName) deck

[5.712]

[5.823]

type instance DeckRep R = Map Text Card

Replacement in src/StateRep.hs at line 36 [5.36]

B:BD[5.824] → [5.824:867]

B:BD[5.978] → [5.978:1078]

instance HunkSYM (R (State CardMap)) where
    chunk oldCardName f = R $ do
        cardFunction <- unR . sequence $ f
        decklist <- get

[5.824]

[5.1426]

instance DeckSYM R where
    empty = R mempty

Replacement in src/StateRep.hs at line 39 [5.36]

B:BD[5.1427] → [6.26:202]

        put $
            Map.alter
                (\oldCard -> foldl' (>>=) oldCard cardFunction)
                (unrefine . runText $ oldCardName)
                decklist

[5.1427]

[6.202]

    deck = R

Replacement in src/StateRep.hs at line 41 [5.36]

B:BD[6.203] → [3.0:58]

∅:D[3.58] → [5.1491:1552]

∅:D[6.263] → [5.1491:1552]

B:BD[5.1491] → [5.1491:1552]

B:BD[5.1552] → [3.59:115]

∅:D[3.115] → [5.1597:1598]

∅:D[6.319] → [5.1597:1598]

B:BD[5.1597] → [5.1597:1598]

B:BD[5.1598] → [3.116:176]

∅:D[3.176] → [5.1664:1730]

∅:D[6.382] → [5.1664:1730]

B:BD[5.1664] → [5.1664:1730]

B:BD[5.1730] → [3.177:238]

    modifyCopies newCopies =
        return $ \oldCard ->
            let newQuantity = newCopies . quantity $ oldCard
             in Just $ oldCard {quantity = newQuantity}
    modifyCategory categoryF =
        return $ \oldCard ->
            let newCategory = categoryF . Deck.category $ oldCard
             in Just $ oldCard {Deck.category = newCategory}

[6.203]

[6.443]

    add cardname initialCategory copies decklist =
        R $
            let newCard = mkCard cardname initialCategory copies
             in Map.alter
                    ( \case
                        Nothing -> Just newCard
                        Just x -> Just $ over categories (Map.insert (toText initialCategory) copies) x
                    )
                    (toText cardname)
                    $ unR decklist

Replacement in src/StateRep.hs at line 52 [5.36]

B:BD[6.444] → [6.444:756]

    deltaCopies delta = return $ \oldCard ->
        let oldCopies = fromIntegral . unrefine . runNumber . quantity $ oldCard
            refinedCopies =
                fmap PositiveNumber . eitherToMaybe . refine . fromIntegral $ oldCopies + delta
         in fmap (\x -> oldCard {quantity = x}) refinedCopies

[6.444]

[5.1780]

    remove cardName categoryName decklist =
        R $
            Map.update
                ( \card ->
                    let newCard = over categories (Map.delete (toText categoryName)) card
                     in if Map.null $ newCard ^. categories
                            then Nothing
                            else Just newCard
                )
                (toText cardName)
                decklist

Replacement in src/StateRep.hs at line 64 [5.36]

B:BD[5.1807] → [5.1807:1881]

eval :: R (State CardMap) a -> CardMap
eval = flip execState mempty . unR

[5.1781]

[5.1881]

eval :: R a -> a
eval = unR

Replacement in src/StateRep.hs at line 67 [5.36]

B:BD[5.1882] → [5.1882:1940]

evalMany :: (Traversable t) => t (RDefault ()) -> CardMap

[5.1882]

[4.17]

evalMany :: (Traversable t) => t (R (DeckRep R) -> R (DeckRep R)) -> DeckRep R

Replacement in src/StateRep.hs at line 70 [5.36]

B:BD[4.52] → [4.52:184]

evalManyOn :: (Traversable t) => t (RDefault ()) -> CardMap -> CardMap
evalManyOn x initDeck = flip execState initDeck $ mapM unR x

[4.52]

evalManyOn ::
    (Traversable t) => t (R (DeckRep R) -> R (DeckRep R)) -> DeckRep R -> DeckRep R
evalManyOn instr initDeck = unR $ foldl' (\acc f -> f acc) (deck initDeck) instr

Replacement in src/Parser.hs at line 8 [5.2023]
B:BD[5.2191] → [5.2191:2205]
```
    readCard,
```
[5.2191]
[5.2205]
```
    readRecord,
```
Insertion in src/Parser.hs at line 13 [5.2023]
[5.2253]
[5.2253]
```
import Control.Monad
```

Replacement in src/Parser.hs at line 33 [5.2023]

B:BD[5.2606] → [5.2606:2677]

readCard :: Category -> Text -> Either [ReadError] Card
readCard c n =

[5.2606]

[5.2677]

readRecord :: Text -> Either [ReadError] (CardName, Copies)
readRecord input =

Replacement in src/Parser.hs at line 49 [5.2023]

B:BD[5.3332] → [5.3332:3471]

        toCard tup = (\(x, y) -> Card y x c) <$> validate tup
     in (toError . bimap (readMaybe @Natural) T.pack . word1 . T.unpack $ n)

[5.3332]

[5.3471]

        toCard tup = (\(x, y) -> (y, x)) <$> validate tup
     in (toError . bimap (readMaybe @Natural) T.pack . word1 . T.unpack $ input)

Replacement in src/Parser.hs at line 53 [5.2023]

B:BD[5.3495] → [5.3495:3575]

readDeckList :: (DeckSYM repr) => FilePath -> IO (Either [ReadError] [repr ()])

[5.3495]

[5.3575]

readDeckList ::
    (DeckSYM repr) =>
    FilePath
    -> IO (Either [ReadError] [repr (DeckRep repr) -> repr (DeckRep repr)])

Replacement in src/Parser.hs at line 59 [5.2023]

B:BD[5.3651] → [5.3651:3864]

    let (mb, sb) = T.breakOn "\n\n" content
        mb' = mapM (readCard mainboard) (T.lines mb)
        sb' = mapM (readCard sideboard) (T.lines . T.stripStart $ sb)
    return $ fmap add <$> liftA2 (++) mb' sb'

[5.3651]

[5.3864]

    let (mb, sb) =
            bimap
                (mapM (parseRecord mainboard) . T.lines)
                (mapM (parseRecord sideboard) . T.lines . T.stripStart)
                $ T.breakOn "\n\n" content
    return $ liftA2 (++) mb sb

Insertion in src/Parser.hs at line 67 [5.2023]

[5.3922]

    parseRecord cat = readRecord >=> \(c, q) -> return $ add c cat q

Insertion in src/Diff.hs at line 1 [5.3955]

[5.3955]

[5.4021]

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE StandaloneKindSignatures #-}

Replacement in src/Diff.hs at line 7 [5.3955]
B:BD[5.4071] → [5.4071:4081]
```
    diff,
```
[5.4071]
[5.4081]
```
    DeckRep,
```
Replacement in src/Diff.hs at line 11 [5.3955]
B:BD[5.4112] → [5.4112:4145]
```
import qualified Data.Map as Map
```
[5.4090]
[5.4185]
```
import Data.Kind
```

Insertion in src/Diff.hs at line 14 [5.3955]

[5.4198]


type DeckRep :: (Type -> Type) -> Type
type family DeckRep a

Insertion in src/Diff.hs at line 19 [5.3955]

[5.4224]

    -- type DeckRep repr
    -- | Create an empty deck
    empty :: repr (DeckRep repr)
    -- | Lift a deck into object scope
    deck :: DeckRep repr -> repr (DeckRep repr)

Replacement in src/Diff.hs at line 28 [5.3955]

B:BD[5.4256] → [5.4256:4283]

    add :: Card -> repr ()

[5.4256]

[5.4283]

    add :: CardName -> CategoryName -> Copies -> repr (DeckRep repr) -> repr (DeckRep repr)

Replacement in src/Diff.hs at line 31 [5.3955]

B:BD[5.4321] → [5.4321:4355]

    remove :: CardName -> repr ()

[5.4321]

[5.4355]

    remove :: CardName -> CategoryName -> DeckRep repr -> repr (DeckRep repr)

Replacement in src/Diff.hs at line 35 [5.3955]

B:BD[5.4414] → [6.757:842]

    chunk :: (Traversable t) => CardName -> t (repr (Card -> Maybe Card)) -> repr ()

[5.4414]

[5.4493]

    chunk :: (Traversable t) => CardName -> t (repr (Card -> Maybe Card)) -> repr (DeckRep repr)-> repr (DeckRep repr)

Replacement in src/Diff.hs at line 38 [5.3955]

B:BD[6.927] → [6.927:1001]

    modifyCategory :: (Category -> Category) -> repr (Card -> Maybe Card)

[6.927]

[6.1001]

    modifyCategory :: (CategoryName -> CategoryName) -> repr (Card -> Maybe Card)

Insertion in src/Deck.hs at line 8 [8.191]

[2.68]

[7.133]

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE DuplicateRecordFields #-}

Deletion in src/Deck.hs at line 27 [8.191]
B:BD[9.45] → [9.45:57]
```
    update,
```

Refactor code to reflect new api changes

Dependencies

In channels

Change contents

Insertion in src/StateRep.hs at line 1 [5.36]

Insertion in src/StateRep.hs at line 5 [5.36]

Replacement in src/StateRep.hs at line 9 [5.36]

Insertion in src/StateRep.hs at line 12 [5.36]

Deletion in src/StateRep.hs at line 19 [5.36]

Replacement in src/StateRep.hs at line 24 [5.36]

Insertion in src/StateRep.hs at line 28 [5.36]