jrvieira/nove - Change VMPZ6XVHIWAVIWHZ6WEXEZRZLDPQN7NWJIW3YHG5YRH4I2BXXMBAC

vs

Created by jrvieira on May 9, 2026

VMPZ6XVHIWAVIWHZ6WEXEZRZLDPQN7NWJIW3YHG5YRH4I2BXXMBAC

Dependencies

In channels

main

Change contents

Replacement in test/Cell.hs at line 3 [3.1]

B:BD[3.21] → [4.10199:10245]

import Zero ( back, forw, prev, next, total )

[3.21]

[3.48]

import Zero ( back, forw, prev, next, total, (?) )

Replacement in test/Cell.hs at line 8 [3.1]

B:BD[3.97] → [2.4819:4902]

import Nove.Draw.Ansi ( Ansi(..), io )
-- import Nove.Draw.Brick ( Brick(..), io )

[3.97]

[3.119]

import Nove.Draw.Ansi qualified as Ansi
import Nove.Draw.Brick qualified as Brick

Replacement in test/Cell.hs at line 11 [3.1]

B:BD[3.120] → [3.120:141]

B:BD[3.141] → [5.1253:1348]

import Terminal.Game
import Terminal.Game.Plane qualified as ATGP ( Cell, creaCell, paletteColorCell, updatePlane )

[3.120]

[3.141]

import System.Environment ( getArgs )

Deletion in test/Cell.hs at line 13 [3.1]
B:BD[3.186] → [2.4903:4934]
```
import Data.List ( elemIndex )
```
Insertion in test/Cell.hs at line 15 [3.1]
[2.4997]
[3.267]
```
import Data.List ( elemIndex )
```

Replacement in test/Cell.hs at line 17 [3.1]

B:BD[3.299] → [4.10297:10343]

import Data.Vector as V ( length, imap, map )

[3.299]

[3.338]

import Data.Map.Strict qualified as M
import Data.Vector qualified as V ( length, imap, map )

Insertion in test/Cell.hs at line 21 [3.1]

[3.369]

import Terminal.Game qualified as ATG
import Graphics.Vty qualified as Vty
import Brick qualified
import Brick.Widgets.Center qualified as Brick
import Brick.Widgets.Border.Style qualified as Brick
import Brick.Widgets.Border qualified as Brick

Insertion in test/Cell.hs at line 32 [3.1]
[3.410]
[3.410]
```
   args <- getArgs
```

Replacement in test/Cell.hs at line 34 [3.1]

B:BD[3.441] → [3.441:450]

B:BD[3.450] → [2.4998:5087]

∅:D[2.5087] → [3.527:556]

B:BD[3.527] → [3.527:556]

   io 19
      State { play = True , algo = Terra , center = 0 , focus = 0 , rand = drop size r }
      (noise r $ verse size)

[3.441]

[3.556]

   let z = maybe (error "need to provide size as first argument") read $ args ? 0
   go (args ? 1) 19
      State { play = True , algo = Terra , center = 0 , focus = 0 , rand = drop z r }
      (noise r $ verse z)
   where

Replacement in test/Cell.hs at line 40 [3.1]

B:BD[3.557] → [3.557:569]

B:BD[3.569] → [4.10344:10354]

size :: Int
size = 42

[3.557]

[3.579]

   go :: Maybe String -> Int -> State -> Verse Hex -> IO ()
   go (Just "brick") = Brick.io
   go _ = Ansi.io

Replacement in test/Cell.hs at line 85 [3.1]
B:BD[3.1533] → [3.1533:1563]
```
instance Ansi State Hex where
```
[3.1533]
[3.1563]
```
instance Ansi.Interface State Hex where
```

Replacement in test/Cell.hs at line 87 [3.1]

B:BD[3.1564] → [3.1564:1642]

   logic :: GEnv -> (State,Verse Hex) -> Event -> Either () (State,Verse Hex)

[3.1564]

[3.1642]

   logic :: ATG.GEnv -> (State,Verse Hex) -> ATG.Event -> Either () (State,Verse Hex)

Replacement in test/Cell.hs at line 89 [3.1]

B:BD[3.1661] → [3.1661:1697]

B:BD[3.1697] → [2.5205:5821]

∅:D[2.5821] → [4.10355:10459]

B:BD[3.2009] → [4.10355:10459]

∅:D[4.10459] → [3.2097:2357]

B:BD[3.2097] → [3.2097:2357]

B:BD[3.2357] → [2.5822:6425]

∅:D[5.1555] → [3.2357:2400]

∅:D[2.6425] → [3.2357:2400]

∅:D[4.10799] → [3.2357:2400]

B:BD[3.2357] → [3.2357:2400]

      | KeyPress 'q' <- e = Left ()
      | KeyPress 'H' <- e = Right (s { center = shift v 1 H $ center s } , v)
      | KeyPress 'J' <- e = Right (s { center = shift v 1 N $ center s } , v)
      | KeyPress 'K' <- e = Right (s { center = shift v 1 I $ center s } , v)
      | KeyPress 'L' <- e = Right (s { center = shift v 1 L $ center s } , v)
      | KeyPress 'h' <- e = Right (s { focus = shift v 1 H $ focus s } , v)
      | KeyPress 'j' <- e = Right (s { focus = shift v 1 N $ focus s } , v)
      | KeyPress 'k' <- e = Right (s { focus = shift v 1 I $ focus s } , v)
      | KeyPress 'l' <- e = Right (s { focus = shift v 1 L $ focus s } , v)
      | KeyPress 'r' <- e = Right (s { rand = drop (V.length $ nodes v) $ rand s } , noise (rand s) v )
      | KeyPress 's' <- e = Right (s { algo = forw $ algo s } , v)
      | KeyPress 'S' <- e = Right (s { algo = back $ algo s } , v)
      | KeyPress 'p' <- e = Right (s { play = not $ play s } , v)
      | KeyPress '.' <- e = Right (s { play = False } , v')
      | KeyPress '_' <- e = Right (s , v { nodes = V.map (\n -> n { atom = prev $ atom n }) $ nodes v })
      | KeyPress '+' <- e = Right (s , v { nodes = V.map (\n -> n { atom = next $ atom n }) $ nodes v })
      | KeyPress '-' <- e = Right (s , upd prev (focus s) v)
      | KeyPress '=' <- e = Right (s , upd next (focus s) v)
      | KeyPress c <- e , isDigit c , n <- digitToInt c , n <= fromEnum (maxBound :: Hex) = Right (s , upd (const $ toEnum n) (focus s) v)
      | KeyPress c <- e , Just n <- elemIndex c ")!@#$%^&*(" , n <= fromEnum (maxBound :: Algo) = Right (s { algo = toEnum n } , v)
      | play s, Tick <- e = Right (s , v')

[3.1661]

[3.2400]

      | ATG.KeyPress 'q' <- e = Left ()
      | ATG.KeyPress 'H' <- e = Right (s { center = shift v 1 H $ center s } , v)
      | ATG.KeyPress 'J' <- e = Right (s { center = shift v 1 N $ center s } , v)
      | ATG.KeyPress 'K' <- e = Right (s { center = shift v 1 I $ center s } , v)
      | ATG.KeyPress 'L' <- e = Right (s { center = shift v 1 L $ center s } , v)
      | ATG.KeyPress 'h' <- e = Right (s { focus = shift v 1 H $ focus s } , v)
      | ATG.KeyPress 'j' <- e = Right (s { focus = shift v 1 N $ focus s } , v)
      | ATG.KeyPress 'k' <- e = Right (s { focus = shift v 1 I $ focus s } , v)
      | ATG.KeyPress 'l' <- e = Right (s { focus = shift v 1 L $ focus s } , v)
      | ATG.KeyPress 'r' <- e = Right (s { rand = drop (V.length $ nodes v) $ rand s } , noise (rand s) v )
      | ATG.KeyPress 's' <- e = Right (s { algo = forw $ algo s } , v)
      | ATG.KeyPress 'S' <- e = Right (s { algo = back $ algo s } , v)
      | ATG.KeyPress 'p' <- e = Right (s { play = not $ play s } , v)
      | ATG.KeyPress '.' <- e = Right (s { play = False } , v')
      | ATG.KeyPress '_' <- e = Right (s , v { nodes = V.map (\n -> n { atom = prev $ atom n }) $ nodes v })
      | ATG.KeyPress '+' <- e = Right (s , v { nodes = V.map (\n -> n { atom = next $ atom n }) $ nodes v })
      | ATG.KeyPress '-' <- e = Right (s , upd prev (focus s) v)
      | ATG.KeyPress '=' <- e = Right (s , upd next (focus s) v)
      | ATG.KeyPress c <- e , isDigit c , n <- digitToInt c , n <= fromEnum (maxBound :: Hex) = Right (s { algo = toEnum n } , v)
      | ATG.KeyPress c <- e , Just n <- elemIndex c ")!@#$%^&*(" , n <= fromEnum (maxBound :: Algo) = Right (s , upd (const $ toEnum n) (focus s) v)
      | play s , ATG.Tick <- e = Right (s , v')

Replacement in test/Cell.hs at line 115 [3.1]

B:BD[3.2473] → [3.2473:2519]

B:BD[3.2519] → [4.10800:10930]

   draw :: GEnv -> (State,Verse Hex) -> Plane
   draw e (s,v) = centerFull e hex & (1,1) % vcat
      [ word "  cells demo" # color White Vivid
      , vcat $ select <$> total

[3.2473]

[4.10930]

   draw :: ATG.GEnv -> (State,Verse Hex) -> ATG.Plane
   draw e (s,v) = ATG.centerFull e hex ATG.& (1,1) ATG.% ATG.vcat
      [ ATG.word "  cells demo" ATG.# ATG.color ATG.White ATG.Vivid
      , ATG.vcat $ select <$> total

Insertion in test/Cell.hs at line 122 [3.1]
[3.2629]
[4.10939]
```
      size :: Int
      size = radius v
```

Replacement in test/Cell.hs at line 125 [3.1]

B:BD[4.10940] → [4.10940:11101]

B:BD[4.11101] → [2.6426:6514]

      select :: Algo -> Plane
      select x = hcat
         [ word (show $ fromEnum x) # color (if algo s == x then Yellow else White) Dull
         , word " "
         , word (toLower <$> show x) # color (if algo s == x then Cyan else White) Dull

[4.10940]

[4.11192]

      select :: Algo -> ATG.Plane
      select x = ATG.hcat
         [ ATG.word (show $ fromEnum x) ATG.# ATG.color (if algo s == x then ATG.Yellow else ATG.White) ATG.Dull
         , ATG.word " "
         , ATG.word (toLower <$> show x) ATG.# ATG.color (if algo s == x then ATG.Cyan else ATG.White) ATG.Dull

Replacement in test/Cell.hs at line 132 [3.1]

B:BD[3.2726] → [3.2726:2745]

      hex :: Plane

[3.2726]

[3.3042]

      hex :: ATG.Plane
      hex = ATG.cellsPlane (succ $ 2 * size * 2) (succ $ 2 * size) [ write (x,y) | x <- [-size..size] , y <- [-size..size] , abs (x + y) <= size ]

Replacement in test/Cell.hs at line 135 [3.1]

B:BD[3.3043] → [5.1719:1766]

      write :: (Int,Int) -> (Coords,ATGP.Cell)

[3.3043]

[2.6515]

      write :: (Int,Int) -> (ATG.Coords,ATG.Cell)

Replacement in test/Cell.hs at line 137 [3.1]

B:BD[2.6533] → [2.6533:6730]

         | n == focus s = (c , ATGP.paletteColorCell k $ ATGP.creaCell $ intToDigit $ fromEnum h)
         | otherwise = (c , ATGP.paletteColorCell k $ ATGP.creaCell $ " ·~+=≠co" !! fromEnum h)

[2.6533]

[3.3141]

         | n == focus s = (c , ATG.paletteColorCell k $ ATG.creaCell $ intToDigit $ fromEnum h)
         | otherwise = (c , ATG.paletteColorCell k $ ATG.creaCell $ " ·~+=≠co" !! fromEnum h)

Replacement in test/Cell.hs at line 148 [3.1]

B:BD[3.3404] → [2.6731:6776]

         (mx,my) = indexToCoord v (center s)

[3.3404]

[3.3452]

         (mx,my) = indexToCoord v $ center s

Replacement in test/Cell.hs at line 155 [3.1]

B:BD[5.1883] → [5.1883:2837]

            | 0 <- fromEnum h , play s = xterm6LevelRGB 0 1 0
            | 1 <- fromEnum h , play s = xterm6LevelRGB 0 1 1
            | 2 <- fromEnum h , play s = xterm6LevelRGB 1 1 2
            | 3 <- fromEnum h , play s = xterm6LevelRGB 2 1 3
            | 4 <- fromEnum h , play s = xterm6LevelRGB 3 1 4
            | 5 <- fromEnum h , play s = xterm6LevelRGB 4 2 5
            | 6 <- fromEnum h , play s = xterm6LevelRGB 5 3 5
            | 7 <- fromEnum h , play s = xterm6LevelRGB 5 4 5
            | 0 <- fromEnum h = xterm24LevelGray 2
            | 1 <- fromEnum h = xterm24LevelGray 5
            | 2 <- fromEnum h = xterm24LevelGray 8
            | 3 <- fromEnum h = xterm24LevelGray 11
            | 4 <- fromEnum h = xterm24LevelGray 14
            | 5 <- fromEnum h = xterm24LevelGray 17
            | 6 <- fromEnum h = xterm24LevelGray 23
            | 7 <- fromEnum h = xterm24LevelGray 23
            | otherwise = xterm24LevelGray 0

[5.1883]

[3.4857]

            | 0 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 0
            | 1 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 1
            | 2 <- fromEnum h , play s = ATG.xterm6LevelRGB 1 1 2
            | 3 <- fromEnum h , play s = ATG.xterm6LevelRGB 2 1 3
            | 4 <- fromEnum h , play s = ATG.xterm6LevelRGB 3 1 4
            | 5 <- fromEnum h , play s = ATG.xterm6LevelRGB 4 2 5
            | 6 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 3 5
            | 7 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 4 5
            | 0 <- fromEnum h = ATG.xterm24LevelGray 2
            | 1 <- fromEnum h = ATG.xterm24LevelGray 5
            | 2 <- fromEnum h = ATG.xterm24LevelGray 8
            | 3 <- fromEnum h = ATG.xterm24LevelGray 11
            | 4 <- fromEnum h = ATG.xterm24LevelGray 14
            | 5 <- fromEnum h = ATG.xterm24LevelGray 17
            | 6 <- fromEnum h = ATG.xterm24LevelGray 23
            | 7 <- fromEnum h = ATG.xterm24LevelGray 23
            | otherwise = ATG.xterm24LevelGray 0
instance Brick.Interface State Hex where
   logic :: Brick.BrickEvent () () -> (State,Verse Hex) -> Maybe (State,Verse Hex)
   logic ev (s,v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'q') []) <- ev = Nothing
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'H') []) <- ev = Just (s { center = shift v 1 H $ center s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'J') []) <- ev = Just (s { center = shift v 1 N $ center s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'K') []) <- ev = Just (s { center = shift v 1 I $ center s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'L') []) <- ev = Just (s { center = shift v 1 L $ center s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'h') []) <- ev = Just (s { focus = shift v 1 H $ focus s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'j') []) <- ev = Just (s { focus = shift v 1 N $ focus s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'k') []) <- ev = Just (s { focus = shift v 1 I $ focus s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'l') []) <- ev = Just (s { focus = shift v 1 L $ focus s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'r') []) <- ev = Just (s { rand = drop (V.length $ nodes v) $ rand s } , noise (rand s) v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 's') []) <- ev = Just (s { algo = forw $ algo s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'S') []) <- ev = Just (s { algo = back $ algo s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar 'p') []) <- ev = Just (s { play = not $ play s } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar '.') []) <- ev = Just (s { play = False } , v')
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar '_') []) <- ev = Just (s , v { nodes = (\n -> n { atom = prev $ atom n }) <$> nodes v })
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar '+') []) <- ev = Just (s , v { nodes = (\n -> n { atom = next $ atom n }) <$> nodes v })
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar '-') []) <- ev = Just (s , upd prev (focus s) v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar '=') []) <- ev = Just (s , upd next (focus s) v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar c) []) <- ev , isDigit c , n <- digitToInt c , n <= fromEnum (maxBound :: Hex) = Just (s { algo = toEnum n } , v)
      | Brick.VtyEvent (Vty.EvKey (Vty.KChar c) []) <- ev , Just n <- elemIndex c ")!@#$%^&*(" , n <= fromEnum (maxBound :: Algo) = Just (s , upd (const $ toEnum n) (focus s) v)
      | Brick.AppEvent () <- ev , play s = Just (s , v')  -- tick
      | otherwise = Just (s , v)
      where
      v' :: Verse Hex
      v'  = sim cells s v
   draw :: (State,Verse Hex) -> [Brick.Widget ()]
   draw (s,v) =
      [ Brick.translateBy (Brick.Location (2,0)) $ Brick.vCenterLayer ui
      , Brick.center hex
      ]
      where

Deletion in test/Cell.hs at line 211 [3.1]

B:BD[3.2745] → [5.1556:1718]

      hex = ATGP.updatePlane (blankPlane (succ $ 2 * size * 2) (succ $ 2 * size)) [ write (x,y) | x <- [-size..size] , y <- [-size..size] , abs (x + y) <= size ]

Solving an order conflict in test/Cell.hs at line 211 [3.1]
[3.4858]

Insertion in test/Cell.hs at line 211 [3.1]

[0.7607]

      size :: Int
      size = radius v
      defaultStyle :: Brick.Widget a -> Brick.Widget a
      defaultStyle = Brick.withDefAttr (Brick.attrName "solid")
         . Brick.withBorderStyle Brick.unicodeRounded
         . Brick.modifyDefAttr (flip Vty.withForeColor Vty.brightBlack)
         . Brick.border
         . Brick.modifyDefAttr (flip Vty.withForeColor Vty.brightWhite)
         . Brick.padLeftRight 1
      ui :: Brick.Widget ()
      ui = defaultStyle $ Brick.vBox $ Brick.str "cells demo" : (Brick.raw . select <$> total)
         where
         select :: Algo -> Vty.Image
         select x = Vty.horizCat
            [ Vty.string (coloured x Vty.yellow) (show $ fromEnum x)
            , Vty.string Vty.defAttr " "
            , Vty.string (coloured x Vty.cyan) (toLower <$> show x)
            ]
         coloured :: Algo -> Vty.Color -> Vty.Attr
         coloured x c
            | algo s == x = Vty.withForeColor Vty.defAttr c
            | otherwise = Vty.withForeColor Vty.defAttr Vty.brightBlack
   -- hex :: Vty.Image
   -- hex = Vty.vertCat [ Vty.horizCat [ M.findWithDefault (Vty.char Vty.defAttr ' ') (row,col) vtycellMap | col <- [0 .. 4*size] ] | row <- [0 .. 2*size] ]
      hex :: Brick.Widget ()
      hex = Brick.Widget Brick.Greedy Brick.Greedy $ do
         ctx <- Brick.getContext
         Brick.render $ Brick.raw $ img ctx
         where
         img ctx = Vty.vertCat [ Vty.horizCat [ M.findWithDefault (Vty.char Vty.defAttr ' ') (row,col) vtycellMap | col <- cols ] | row <- rows ]
            where
            tw = Brick.availWidth ctx
            th = Brick.availHeight ctx
            iw = 4*size + 1
            ih = 2*size + 1
            dx = max 0 (div (iw - tw) 2)
            dy = max 0 (div (ih - th) 2)
            cols = [dx .. min (dx + tw - 1) (iw - 1)]
            rows = [dy .. min (dy + th - 1) (ih - 1)]
      vtycellMap :: M.Map (Int,Int) Vty.Image
      vtycellMap = M.fromList [ ((size - y , 2*(x+size)+y) , Vty.char attr ch) | x <- [-size..size] , y <- [-size..size] , abs (x+y) <= size , let (attr,ch) = vtycell x y ]
      vtycell :: Int -> Int -> (Vty.Attr,Char)
      vtycell x y = (Vty.withForeColor Vty.defAttr col , ch)
         where
         h = get v n
         n = shift v mx L . shift v my I $ coordToIndex v (mod (x - div y size * size) (3*size) , mod y size)
         (mx,my) = indexToCoord v $ center s
         ch | n == focus s = intToDigit $ fromEnum h
            | otherwise = " ·~+=≠co" !! fromEnum h
         col = k (fromEnum h)
      k :: Int -> Vty.Color
      k i
         | play s , 0 <- i = xrgb 0 1 0
         | play s , 1 <- i = xrgb 0 1 1
         | play s , 2 <- i = xrgb 1 1 2
         | play s , 3 <- i = xrgb 2 1 3
         | play s , 4 <- i = xrgb 3 1 4
         | play s , 5 <- i = xrgb 4 2 5
         | play s , 6 <- i = xrgb 5 3 5
         | play s , 7 <- i = xrgb 5 4 5
         |          0 <- i = xgray 2
         |          1 <- i = xgray 5
         |          2 <- i = xgray 8
         |          3 <- i = xgray 11
         |          4 <- i = xgray 14
         |          5 <- i = xgray 17
         |          6 <- i = xgray 23
         |          7 <- i = xgray 23
         | otherwise       = xgray 0
      -- xterm 6-level RGB cube  (colors 16–231)
      xrgb :: Int -> Int -> Int -> Vty.Color
      xrgb r g b = Vty.Color240 $ fromIntegral (36*r + 6*g + b)
      -- xterm 24-level greyscale ramp (colors 232–255)
      xgray :: Int -> Vty.Color
      xgray n = Vty.Color240 $ fromIntegral (216 + n)

Replacement in src/Nove/Draw/Ansi.hs at line 9 [3.5092]
B:BD[3.5180] → [3.5180:5215]
```
class Atom a => Ansi state a where
```
[3.5180]
[3.5215]
```
class Atom a => Interface state a where
```

Replacement in src/Nove/Draw/Ansi.hs at line 13 [3.5092]

B:BD[3.5334] → [3.5334:5389]

io :: Ansi state a => TPS -> state -> Verse a -> IO ()

[3.5334]

[3.5389]

io :: Interface state a => Int -> state -> Verse a -> IO ()

Replacement in src/Nove/Draw/Ansi.hs at line 16 [3.5092]
B:BD[3.5424] → [3.5424:5443]
```
      { gTPS = tps
```
[3.5424]
[3.5443]
```
      { gTPS = toInteger tps
```
Deletion in nove.cabal at line 30 [6.12206]
B:BD[6.12703] → [2.6874:6888]
```
      , brick
```
Insertion in nove.cabal at line 33 [6.12206]
[2.6927]
[6.12730]
```
      , brick
```
Deletion in nove.cabal at line 54 [6.12206]
∅:D[7.6942] → [6.13066:13093]
B:BD[6.13066] → [6.13066:13093]
```
      , ansi-terminal-game
```
Insertion in nove.cabal at line 55 [6.12206]
[8.4217]
[6.13093]
```
      , ansi-terminal-game
```
Deletion in nove.cabal at line 66 [6.12206]
B:BD[9.1773] → [9.1773:1800]
```
      , ansi-terminal-game
```
Insertion in nove.cabal at line 67 [6.12206]
[9.1815]
[9.1815]
```
      , ansi-terminal-game
```
Insertion in nove.cabal at line 78 [6.12206]
[10.3871]
[7.6943]
```
      , containers
```
Insertion in nove.cabal at line 80 [6.12206]
[7.6958]
[10.3890]
```
      , colour
```
Replacement in nove.cabal at line 82 [6.12206]
B:BD[10.3917] → [10.3917:3932]
```
      , colour
```
[10.3917]
[10.3932]
```
      , vty
      , vty-crossplatform
      , brick
```
Insertion in nove.cabal at line 95 [6.12206]
[2.7103]
[2.7103]
```
      , colour
```
Deletion in nove.cabal at line 97 [6.12206]
B:BD[2.7130] → [2.7130:7145]
```
      , colour
```
Replacement in cabal.project at line 2 [6.13131]
B:BD[6.13155] → [11.4761:4782]
```
   , ./src/*/*.cabal
```
[6.13155]
[6.13176]
```
-- , ./src/*/*.cabal
```

Insertion in cabal.project at line 8 [6.13131]

[6.13279]


source-repository-package
   type: git
   location: git@gitlab.com:jrvieira1/ansi-terminal-game.git
   branch: master

vs

Dependencies

In channels

Change contents

Replacement in test/Cell.hs at line 3 [3.1]

Replacement in test/Cell.hs at line 8 [3.1]

Replacement in test/Cell.hs at line 11 [3.1]

Deletion in test/Cell.hs at line 13 [3.1]

Insertion in test/Cell.hs at line 15 [3.1]

Replacement in test/Cell.hs at line 17 [3.1]

Insertion in test/Cell.hs at line 21 [3.1]

Insertion in test/Cell.hs at line 32 [3.1]

Replacement in test/Cell.hs at line 34 [3.1]

Replacement in test/Cell.hs at line 40 [3.1]

Replacement in test/Cell.hs at line 85 [3.1]

Replacement in test/Cell.hs at line 87 [3.1]

Replacement in test/Cell.hs at line 89 [3.1]

Replacement in test/Cell.hs at line 115 [3.1]

Insertion in test/Cell.hs at line 122 [3.1]

Replacement in test/Cell.hs at line 125 [3.1]

Replacement in test/Cell.hs at line 132 [3.1]

Replacement in test/Cell.hs at line 135 [3.1]

Replacement in test/Cell.hs at line 137 [3.1]

Replacement in test/Cell.hs at line 148 [3.1]

Replacement in test/Cell.hs at line 155 [3.1]

Deletion in test/Cell.hs at line 211 [3.1]

Solving an order conflict in test/Cell.hs at line 211 [3.1]

Insertion in test/Cell.hs at line 211 [3.1]

Replacement in src/Nove/Draw/Ansi.hs at line 9 [3.5092]

Replacement in src/Nove/Draw/Ansi.hs at line 13 [3.5092]

Replacement in src/Nove/Draw/Ansi.hs at line 16 [3.5092]

Deletion in nove.cabal at line 30 [6.12206]

Insertion in nove.cabal at line 33 [6.12206]

Deletion in nove.cabal at line 54 [6.12206]

Insertion in nove.cabal at line 55 [6.12206]

Deletion in nove.cabal at line 66 [6.12206]

Insertion in nove.cabal at line 67 [6.12206]

Insertion in nove.cabal at line 78 [6.12206]

Insertion in nove.cabal at line 80 [6.12206]

Replacement in nove.cabal at line 82 [6.12206]

Insertion in nove.cabal at line 95 [6.12206]

Deletion in nove.cabal at line 97 [6.12206]

Replacement in cabal.project at line 2 [6.13131]

Insertion in cabal.project at line 8 [6.13131]