jrvieira/nove - Change CHFKQM47XREZBR5LKV6J4G7FYXQD3SA5XGDAY7P4JF6IBCMUGG3QC

vs

Created by jrvieira on May 8, 2026

CHFKQM47XREZBR5LKV6J4G7FYXQD3SA5XGDAY7P4JF6IBCMUGG3QC

Dependencies

In channels

main

Change contents

Replacement in test/Dois.hs at line 7 [2.1]
B:BD[2.74] → [2.74:114]
```
import Zero ( total )
import Zero.Queue
```
[2.74]
[2.114]
```
import System.Environment ( getArgs )
```

Replacement in test/Dois.hs at line 9 [2.1]

B:BD[2.115] → [2.115:213]

import Data.List ( intersperse )
import Data.Foldable ( toList )
import Data.Vector as V ( find )

[2.115]

[2.213]

import Data.Vector as V ( Vector, (//), generate, find, findIndex, length , break )

Insertion in test/Dois.hs at line 11 [2.1]
[2.243]
[2.243]
```
import Data.Maybe
import Data.Char ( digitToInt )
```
Insertion in test/Dois.hs at line 14 [2.1]
[2.275]
[2.275]
```
import Data.Function ( on )
```

Replacement in test/Dois.hs at line 16 [2.1]

B:BD[2.296] → [2.296:453]

import Terminal.Game.Plane qualified as ATGP ( Cell, creaCell, colorCell, rgbColorCell, mapPlane, updatePlane )
import System.Random ( randoms, initStdGen )

[2.296]

[2.453]

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

Replacement in test/Dois.hs at line 22 [2.1]

B:BD[2.486] → [2.486:543]

main = io 20 State { center = 0 , focus = 0 } $ verse 42

[2.486]

[2.543]

main = do
   p : _ <- map read <$> getArgs
   io 12 State { center = 0 , focus = 0 , turn = 0 , players = p , hand = Nothing , frame = 0 } (verse 3 :: Verse Stack)

Deletion in test/Dois.hs at line 26 [2.1]

B:BD[2.544] → [2.544:909]

newtype Team = Team { n :: Word , color :: Color }
data Place = None | Some Place
newtype Dois = Dois Team Piece
instance Atom Dois where
   void = None
   mass a
      | None <- a = False
      | otherwise = True
   move a
      | Robot {} <- a , Move dir : _ <- ops a = Just dir
      | Box {} <- a = push a
      | otherwise = Nothing
data Mode = Dumb | Full

Replacement in test/Dois.hs at line 27 [2.1]

B:BD[2.928] → [2.928:1040]

   { rand :: [Int]
   , center :: Int
   , input :: (Maybe Char,Queue Char)
   , mode :: Mode
   , play :: Bool

[2.928]

[2.1040]

   { center :: Int
   , focus :: Int
   , turn :: Team
   , players :: Int
   , hand :: Maybe Int
   , frame :: Int

Replacement in test/Dois.hs at line 35 [2.1]
B:BD[2.1046] → [2.1046:1054]
```
-- util
```
[2.1046]
[2.1054]
```
-- Stack 000 001 010 011 100 101 110 111
```

Replacement in test/Dois.hs at line 37 [2.1]

B:BD[2.1055] → [2.1055:1144]

me :: Unit -> Bool
me a
   | Robot {} <- a , "@" <- name a = True
   | otherwise = False

[2.1055]

[2.1144]

type Team = Int
data Piece = Piece { team :: Team , size :: Int }
type Stack = V.Vector (Maybe Piece)

Replacement in test/Dois.hs at line 41 [2.1]
B:BD[2.1145] → [2.1145:1163]
```
-- Unit Automaton
```
[2.1145]
[2.1163]
```
instance Eq Piece where
   (==) = on (==) size
```

Replacement in test/Dois.hs at line 44 [2.1]

B:BD[2.1164] → [2.1164:1221]

demo :: Automaton State Unit
demo = Automaton f
   where

[2.1164]

[2.1221]

instance Ord Piece where
   compare = on compare size

Replacement in test/Dois.hs at line 47 [2.1]

B:BD[2.1222] → [2.1222:1731]

   f :: Cell State Unit
   f s ns u
      | Robot { ops = [] } <- u , Just dir <- push     = u { ops = [Move dir] }  -- push
      | me u                                           = me'
      | Robot {} <- u                                  = u { ops = drop 1 $ ops u }
      | Box { push = Nothing } <- u , Just dir <- push = u { push = Just dir }  -- push
      | Box {} <- u                                    = Box { push = Nothing }
      | otherwise                                      = u
      where

[2.1222]

[2.1731]

up :: Stack -> Maybe (Piece,Stack)
up s
   | Just i <- V.findIndex isJust s , Just p <- showing s = Just (p , s // [(i , Nothing)])
   | otherwise = Nothing

Replacement in test/Dois.hs at line 52 [2.1]

B:BD[2.1732] → [2.1732:2028]

      me' :: Unit
         | Just 'h' <- fst $ input s = u { ops = [Move H] }
         | Just 'j' <- fst $ input s = u { ops = [Move N] }
         | Just 'k' <- fst $ input s = u { ops = [Move I] }
         | Just 'l' <- fst $ input s = u { ops = [Move L] }
         | otherwise = u { ops = [] }

[2.1732]

[2.2028]

down :: Piece -> Stack -> Maybe Stack
down p s
   | (n,j) <- V.break isJust s
   , Just p > showing j
   , l <- V.length n
   , l > 0
   = Just $ s // [(pred l , Just p)]
   | otherwise = Nothing
showing :: Stack -> Maybe Piece
showing s
   | Just p <- V.find isJust s = p
   | otherwise = Nothing
instance Atom Stack where
   void = V.generate 3 $ const Nothing
   mass = const True
   move = const Nothing

Replacement in test/Dois.hs at line 71 [2.1]

B:BD[2.2029] → [2.2029:2164]

      push :: Maybe Dir
         | [dir] <- Prelude.filter p total = Just $ opposite dir
         | otherwise = Nothing
         where

[2.2029]

[2.2164]

-- util

Replacement in test/Dois.hs at line 73 [2.1]

B:BD[2.2165] → [2.2165:2266]

         p :: Dir -> Bool
         p dir = mass n && move n == Just (opposite dir)
            where

[2.2165]

[2.2266]

demo :: Automaton State Stack
demo = Automaton f
   where

Replacement in test/Dois.hs at line 77 [2.1]

B:BD[2.2267] → [2.2267:2312]

            n :: Unit
            n = ns dir

[2.2267]

[2.2312]

   f :: Cell State Stack
   f s ns u = u

Replacement in test/Dois.hs at line 80 [2.1]
B:BD[2.2313] → [2.2313:2344]
```
instance Ansi State Unit where
```
[2.2313]
[2.2344]
```
instance Ansi State Stack where
```

Replacement in test/Dois.hs at line 83 [2.1]

B:BD[2.2357] → [2.2357:2437]

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

[2.2357]

[2.2437]

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

Replacement in test/Dois.hs at line 85 [2.1]

B:BD[2.2456] → [2.2456:3666]

      | KeyPress 'q'  <- e = Left ()
      | KeyPress 'p'  <- e = Right (s { play = True } , v)
      | KeyPress 'P'  <- e = Right (s { play = False } , v)
      | KeyPress 'c'  <- e = Right (s { mode = Dumb } , v)
      | KeyPress 'C'  <- e = Right (s { mode = Full } , v)
      | 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 '.'  <- e = Right (s' { play = False } , sim demo s' v)
      | KeyPress  k   <- e = Right (s { input = input' k } , v)
      | play s , Tick <- e = Right (s' , sim demo s' v)
      | otherwise          = Right (s , v)
      where
      -- prevent repeat before tick
      input' :: Char -> (Maybe Char,Queue Char)
      input' k
      -- | Just (q,_) <- dequeue $ snd $ input s , k == q = input s
         | otherwise = enqueue k <$> input s
      z :: State
         | Just (c,q) <- dequeue $ snd $ input s = s { input = (Just c , q) }
         | otherwise = s { input = (Nothing , snd $ input s) }

[2.2456]

[2.3666]

      | Tick <- e = Right (s { frame = succ $ frame s } , v)
      | 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 '\ESC' <- e = Right (s { hand = Nothing} , v)
      -- up
      | KeyPress ' ' <- e
      , Nothing <- hand s  -- empty hand
      , Just p <- showing $ get v $ focus s , team p == turn s  -- top is team
      = Right (s { hand = Just $ focus s } , v)
      -- cancel
      | KeyPress ' ' <- e
      , Just pι <- hand s , focus s == pι
      = Right (s { hand = Nothing } , v)
      -- down
      | KeyPress ' ' <- e
      , Just pι <- hand s
      , fι <- focus s
      , orig <- get v pι
      , dest <- get v fι
      , Just (p,orig') <- up orig
      , Just dest' <- down p dest
      = Right (s { hand = Nothing , turn = mod (succ $ turn s) (players s) } , sets [(pι , orig') , (fι , dest')] v )

Replacement in test/Dois.hs at line 114 [2.1]

B:BD[2.3667] → [2.3667:3758]

      s' :: State
      -- | Just 'x' <- k = z { }
         | otherwise = z
         where

[2.3667]

[2.3758]

      | KeyPress k <- e , elem k $ take 3 ['1','2','3']
      , Just stack <- down (Piece (turn s) (pred $ digitToInt k)) (get v $ focus s)
      = Right (s { hand = Nothing , turn = mod (succ $ turn s) (players s) } , set stack (focus s) v )

Replacement in test/Dois.hs at line 118 [2.1]

B:BD[2.3759] → [2.3759:3811]

         k :: Maybe Char
         k = fst $ input z

[2.3759]

[2.3811]

      | otherwise = Right (s,v)

Replacement in test/Dois.hs at line 122 [2.1]

B:BD[2.3824] → [2.3824:3980]

   draw :: GEnv -> (State,Verse Unit) -> Plane
   draw e (s,v) = foldl (&) (blankPlaneFull e *** hex)
      [ (1,1) % ui
      , (1,1) %^> word "nove demo"

[2.3824]

[2.3980]

   draw :: GEnv -> (State,Verse Stack) -> Plane
   draw e (s,v) = blankPlaneFull e & (1,1) % hcat
      [ hex
      , ui

Deletion in test/Dois.hs at line 132 [2.1]
B:BD[2.4036] → [2.4036:4079]
```
      (mx,my) = indexToCoord v (center s)
```

Replacement in test/Dois.hs at line 133 [2.1]

B:BD[2.4126] → [2.4126:4193]

      write (x,y) = (c , cellStyle a $ ATGP.creaCell $ grapheme a)

[2.4126]

[2.4193]

      write (x,y)
         | n == focus s , odd $ frame s = (c,ATGP.creaCell ' ')
         | Just n == hand s , odd $ frame s = (c,ATGP.creaCell ' ')
         | otherwise = (c,atgpcell $ showing $ get v n)

Deletion in test/Dois.hs at line 139 [2.1]
B:BD[2.4209] → [2.4209:4250]
```
         a :: Unit
         a = get v n
```
Insertion in test/Dois.hs at line 142 [2.1]
[2.4425]
[2.4425]
```
         (mx,my) = indexToCoord v (center s)
```

Replacement in test/Dois.hs at line 159 [2.1]

B:BD[2.4913] → [2.4913:4977]

      ui = pad 2 $ vcat $ intersperse (cell ' ')
         [ key

[2.4913]

[2.4977]

      ui = pad 2 $ vcat
         [ bold $ invert $ word (" Player " <> show (turn s) <> " ") # uncurry color (colors !! turn s)

Replacement in test/Dois.hs at line 162 [2.1]

B:BD[2.4993] → [2.4993:5101]

            [ scope $ V.find (me . atom) $ nodes v
            , cell ' '
            , vcat [word "",info]

[2.4993]

[2.5101]

            [ word "hand: "
            , showhand

Deletion in test/Dois.hs at line 166 [2.1]

B:BD[2.5126] → [2.5126:6150]

         where
         (c,q) = input s
         key :: Plane
         key = word (maybe id (:) c $ toList q) # color Black Vivid
         info :: Plane
            | Just n <- V.find (me . atom) $ nodes v = word $ show $ atom n
            | otherwise = word "no robot found!" # color Red Vivid
      scope :: Maybe (Node Unit) -> Plane
      scope mn
         | Just n <- mn , ns <- neighbour v (ix n) = foldl (&) (blankPlane 5 3)
            [ (1,2) % let a = get v $ ns U in cell (grapheme a) # cellDraw a
            , (1,4) % let a = get v $ ns I in cell (grapheme a) # cellDraw a
            , (2,1) % let a = get v $ ns H in cell (grapheme a) # cellDraw a
            , (2,3) % let a = atom n in cell (grapheme a)
            , (2,5) % let a = get v $ ns L in cell (grapheme a) # cellDraw a
            , (3,2) % let a = get v $ ns N in cell (grapheme a) # cellDraw a
            , (3,4) % let a = get v $ ns M in cell (grapheme a) # cellDraw a
            ]
         | otherwise = blankPlane 5 3
         where

Replacement in test/Dois.hs at line 167 [2.1]

B:BD[2.6151] → [2.6151:6236]

         cellDraw  :: Unit -> Draw
         cellDraw a = ATGP.mapPlane $ cellStyle a

[2.6151]

[2.6236]

      showhand :: Plane
         | Just hι <- hand s
         , Just p <- showing $ get v hι
         = word (pure $ ['▂','▄','▇'] !! size p) # uncurry color (colors !! team p)
         | otherwise = word "empty"

Replacement in test/Dois.hs at line 175 [2.1]

B:BD[2.6254] → [2.6254:6302]

      grapheme :: Unit -> Char
      grapheme a

[2.6254]

[2.6302]

      atgpcell :: Maybe Piece -> ATGP.Cell
      atgpcell Nothing = ATGP.colorCell Black Vivid $ ATGP.creaCell '.'
      atgpcell (Just p) = uncurry ATGP.colorCell (colors !! team p) $ ATGP.creaCell (['▂','▄','▇'] !! size p)

Replacement in test/Dois.hs at line 179 [2.1]

B:BD[2.6303] → [2.6303:6401]

         | None     <- a , Dumb <- mode s = '.'
         | None     <- a , Full <- mode s = '∙'

[2.6303]

[2.6401]

      colors :: [(Color, ColorIntensity)]
      colors =
         [ (Green,Dull)
         , (Blue,Dull)
         , (Red,Dull)
         , (Yellow,Dull)
         , (Cyan,Dull)
         , (Magenta,Dull)
         , (White,Dull)
         , (Green,Vivid)
         , (Blue,Vivid)
         , (Red,Vivid)
         , (Yellow,Vivid)
         , (Cyan,Vivid)
         , (Magenta,Vivid)
         , (White,Vivid)
         ]

Deletion in test/Dois.hs at line 197 [2.1]

B:BD[2.6402] → [2.6402:10161]

         | Wall     <- a                  = '#'
         | Box {}   <- a                  = 'x'
         | Robot {} <- a                  = maybe 'o' (const '@') $ move a
      cellStyle :: Unit -> ATGP.Cell -> ATGP.Cell
      cellStyle a
         | Dumb <- mode s , me a = ATGP.colorCell White Dull
         | Dumb <- mode s , not (mass a) = ATGP.colorCell Black Vivid
         | Dumb <- mode s , Robot {} <- a , "t0"  <- name a = ATGP.colorCell Blue Dull
         | Dumb <- mode s , Robot {} <- a , "t1"  <- name a = ATGP.colorCell Magenta Dull
         | Dumb <- mode s , Robot {} <- a , "t2"  <- name a = ATGP.colorCell Red Dull
         | Dumb <- mode s , Robot {} <- a , "d0"  <- name a = ATGP.colorCell Yellow Dull
         | Dumb <- mode s , Robot {} <- a , "d1"  <- name a = ATGP.colorCell Green Dull
         | Dumb <- mode s , Robot {} <- a , 'L':_ <- name a = ATGP.colorCell Cyan Dull
         | Dumb <- mode s , Robot {} <- a , "r0"  <- name a = ATGP.colorCell White Vivid
         | Dumb <- mode s , Robot {} <- a , "r1"  <- name a = ATGP.colorCell Black Vivid
         | Dumb <- mode s , Robot {} <- a , "m0"  <- name a = ATGP.colorCell Green Vivid
         | Dumb <- mode s , Robot {} <- a , "m1"  <- name a = ATGP.colorCell Green Vivid
         | Dumb <- mode s , Robot {} <- a , "p0"  <- name a = ATGP.colorCell White Dull
         | Dumb <- mode s , Robot {} <- a , "Tp"  <- name a = ATGP.colorCell White Dull
         | Dumb <- mode s , Robot {} <- a , "T0"  <- name a = ATGP.colorCell Blue Dull
         | Dumb <- mode s , Robot {} <- a , "T1"  <- name a = ATGP.colorCell Magenta Dull
         | Dumb <- mode s , Robot {} <- a , "T2"  <- name a = ATGP.colorCell Red Dull
         | Dumb <- mode s = ATGP.colorCell White Vivid
         | Full <- mode s , me a = ATGP.rgbColorCell $ sRGB24 0x21 0xb2 0x8e  -- #21b28e
         | Full <- mode s , not (mass a) = ATGP.rgbColorCell $ sRGB24 0x66 0x66 0x66  -- #666666
         | Full <- mode s , Robot {} <- a , "t0"  <- name a = ATGP.rgbColorCell $ sRGB24 0x66 0x66 0x99  -- #666699
         | Full <- mode s , Robot {} <- a , "t1"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x66 0x99  -- #996699
         | Full <- mode s , Robot {} <- a , "t2"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x66 0x66  -- #996666
         | Full <- mode s , Robot {} <- a , "d0"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x99 0x66  -- #999966
         | Full <- mode s , Robot {} <- a , "d1"  <- name a = ATGP.rgbColorCell $ sRGB24 0x66 0x99 0x66  -- #669966
         | Full <- mode s , Robot {} <- a , 'L':_ <- name a = ATGP.rgbColorCell $ sRGB24 0x66 0x99 0x99  -- #669999
         | Full <- mode s , Robot {} <- a , "r0"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x99 0x99  -- #999999
         | Full <- mode s , Robot {} <- a , "r1"  <- name a = ATGP.rgbColorCell $ sRGB24 0x66 0x66 0x66  -- #666666
         | Full <- mode s , Robot {} <- a , "m0"  <- name a = ATGP.rgbColorCell $ sRGB24 0x93 0xe9 0xbe  -- #93e9be
         | Full <- mode s , Robot {} <- a , "m1"  <- name a = ATGP.rgbColorCell $ sRGB24 0x93 0xe9 0xbe  -- #93e9be
         | Full <- mode s , Robot {} <- a , "p0"  <- name a = ATGP.rgbColorCell $ sRGB24 0xff 0xff 0xff  -- #ffffff
         | Full <- mode s , Robot {} <- a , "Tp"  <- name a = ATGP.rgbColorCell $ sRGB24 0xff 0xff 0xff  -- #ffffff
         | Full <- mode s , Robot {} <- a , "T0"  <- name a = ATGP.rgbColorCell $ sRGB24 0x66 0x66 0x99  -- #666699
         | Full <- mode s , Robot {} <- a , "T1"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x66 0x99  -- #996699
         | Full <- mode s , Robot {} <- a , "T2"  <- name a = ATGP.rgbColorCell $ sRGB24 0x99 0x66 0x66  -- #996666
         | Full <- mode s = ATGP.rgbColorCell $ sRGB24 0x99 0x99 0x99  -- #999999

Replacement in test/Demo.hs at line 162 [4.135]

B:BD[3.5147] → [3.5147:5215]

      -- | Just (q,_) <- dequeue $ snd $ input s , k == q = input s

[3.5147]

[3.5215]

         | Just (q,_) <- dequeue $ snd $ input s , k == q = input s

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

B:BD[5.97] → [5.97:119]

import Nove.Draw.Ansi

[5.97]

[5.119]

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

Insertion in test/Cell.hs at line 14 [5.1]
[5.186]
[6.1349]
```
import Data.List ( elemIndex )
```

Replacement in test/Cell.hs at line 16 [5.1]

B:BD[6.1376] → [2.10246:10296]

import Data.Char ( isDigit, digitToInt, toLower )

[6.1376]

[5.267]

import Data.Char ( isDigit, digitToInt, intToDigit, toLower )

Replacement in test/Cell.hs at line 27 [5.1]

B:BD[5.450] → [5.450:527]

      State { play = True , algo = Terra , center = 0 , rand = drop size r }

[5.450]

[5.527]

      State { play = True , algo = Terra , center = 0 , focus = 0 , rand = drop size r }

Replacement in test/Cell.hs at line 46 [5.1]

B:BD[5.881] → [5.881:964]

data State = State { play :: Bool , algo :: Algo , center :: Int , rand :: [Int] }

[5.881]

[5.964]

data State = State
   { play :: Bool
   , algo :: Algo
   , center :: Int
   , focus :: Int
   , rand :: [Int]
   }

Replacement in test/Cell.hs at line 79 [5.1]

B:BD[5.1697] → [5.1697:2009]

      | 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)

[5.1697]

[2.10355]

      | 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)

Replacement in test/Cell.hs at line 92 [5.1]

B:BD[5.2357] → [2.10460:10799]

      | 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 c <- e , isDigit c , n <- digitToInt c , n <= fromEnum (maxBound :: Algo) = Right (s { algo = toEnum n } , v)

[5.2357]

      | 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)

Replacement in test/Cell.hs at line 116 [5.1]

B:BD[2.11101] → [2.11101:11192]

         , word (fmap toLower $ show x) # color (if algo s == x then Cyan else White) Dull

[2.11101]

[2.11192]

         , word (toLower <$> show x) # color (if algo s == x then Cyan else White) Dull

Replacement in test/Cell.hs at line 123 [5.1]

B:BD[6.1766] → [6.1766:1862]

      write (x,y) = (c , ATGP.paletteColorCell k $ ATGP.creaCell $ " ·~+=≠co" !! fromEnum h)

[6.1766]

[5.3141]

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

Deletion in test/Cell.hs at line 134 [5.1]
B:BD[5.3385] → [5.3385:3403]
```
            where
```

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

B:BD[5.3404] → [5.3404:3452]

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

[5.3404]

[5.3452]

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

Replacement in test/Cell.hs at line 139 [5.1]

B:BD[5.3567] → [5.3567:3628]

         c = join bimap succ (y + size , 2 * (x + size) + y)

[5.3567]

[5.3628]

         c = join bimap succ (size - y , 2 * (x + size) + y)

Insertion in nove.cabal at line 24 [4.12206]
[3.12546]
[4.12587]
```
      , Nove.Draw.Brick
```
Insertion in nove.cabal at line 30 [4.12206]
[4.12703]
[4.12703]
```
      , brick
```
Insertion in nove.cabal at line 32 [4.12206]
[4.12730]
[4.12730]
```
      , vty
      , vty-crossplatform
```
Deletion in nove.cabal at line 68 [4.12206]
B:BD[7.1815] → [3.12547:12562]
```
      , random
```

Insertion in nove.cabal at line 82 [4.12206]

[8.3933]

executable dois
   import: opts
   ghc-options: -threaded -rtsopts
   hs-source-dirs: test
   main-is: Dois.hs
   build-depends: base
      , zero
      , nove
      , vector
      , ansi-terminal-game
      , colour

vs