jrvieira/nove - Change NQEZG66FQWQQOOYXN2GK7MHIQH25QBBNKE37GGDJBCHCSKWJZABQC

vs

Created by jrvieira on May 5, 2026

NQEZG66FQWQQOOYXN2GK7MHIQH25QBBNKE37GGDJBCHCSKWJZABQC

Dependencies

In channels

main

Change contents

Replacement in test/Test.hs at line 74 [4.19]

B:BD[3.111] → [3.111:166]

   a == b = on (==) atom a b && on (==) neighbours a b

[3.111]

[5.1846]

   a == b = on (==) atom a b && on (==) ix a b

Insertion in test/Maze.hs at line 10 [7.1]

[6.48]

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

Deletion in test/Maze.hs at line 12 [7.1]
B:BD[6.93] → [8.16:44]
```
import Data.List ( foldl' )
```
Insertion in test/Maze.hs at line 87 [7.1]
[9.1286]
[9.1286]
```
      | KeyPress 'q' <- e = Left ()
```

Replacement in test/Maze.hs at line 91 [7.1]

B:BD[9.1365] → [9.1365:1460]

   draw e (s,v) = centerFull e $ hcat [hex,ui] & (1,1) % makeTransparent ' ' (word "hex maze")

[9.1365]

[9.1460]

   draw e (s,v) = centerFull e hex & (1,1) % makeTransparent ' ' (word "hex maze")

Replacement in test/Maze.hs at line 98 [7.1]

B:BD[9.1589] → [8.70:180]

      hex = foldl' (&) canvas [ write (x,y) | x <- [-size..size] , y <- [-size..size] , abs (x + y) <= size ]

[9.1589]

[9.1698]

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

Replacement in test/Maze.hs at line 107 [7.1]

B:BD[9.1887] → [9.1887:1920]

      write :: (Int,Int) -> Draw

[9.1887]

[9.1920]

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

Replacement in test/Maze.hs at line 109 [7.1]

B:BD[9.1938] → [9.1938:2113]

         | Just _ <- look h = c %.< cell '*' # color White Dull
         | 0 < i h = c %.< cell 'o' # rgbColor (spectrum $ i h + rand s)
         | otherwise = c %.< cell ' '

[9.1938]

[9.2113]

         | Just _ <- look h = (c , ATGP.colorCell White Dull $ ATGP.creaCell '*')
         | 0 < i h = (c , ATGP.rgbColorCell (spectrum $ i h + rand s) $ ATGP.creaCell 'o')
         | otherwise = (c , ATGP.creaCell ' ')

Deletion in test/Maze.hs at line 127 [7.1]

B:BD[9.2600] → [9.2600:2742]


      ui :: Plane
   -- ui = word "> ui content here <"
      ui = foldl (&) canvas
         [ (1,1) % vcat [info]
         ]
         where

Deletion in test/Maze.hs at line 128 [7.1]

B:BD[6.3687] → [9.2743:2797]

         info :: Plane
         info = word "mazing"

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

B:BD[10.3411] → [10.3411:3464]

B:BD[10.3464] → [2.541:799]

         | Just n <- mn = foldl (&) (blankPlane 5 3)
            [ (1,2) % let a = get v $ neighbour n U in cell (grapheme a) # cellDraw a
            , (1,4) % let a = get v $ neighbour n I in cell (grapheme a) # cellDraw a
            , (2,1) % let a = get v $ neighbour n H in cell (grapheme a) # cellDraw a

[10.3411]

[3.1636]

         | 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

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

B:BD[3.1694] → [2.800:1058]

            , (2,5) % let a = get v $ neighbour n L in cell (grapheme a) # cellDraw a
            , (3,2) % let a = get v $ neighbour n N in cell (grapheme a) # cellDraw a
            , (3,4) % let a = get v $ neighbour n M in cell (grapheme a) # cellDraw a

[3.1694]

[9.7760]

            , (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

Insertion in test/Cell.hs at line 11 [11.1]

[11.141]

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

Replacement in test/Cell.hs at line 13 [11.1]

B:BD[11.186] → [8.453:481]

import Data.List ( foldl' )

[11.186]

import Data.Word ( Word8 )
import Data.Char ( isDigit, digitToInt )

Replacement in test/Cell.hs at line 31 [11.1]
B:BD[11.569] → [8.482:492]
```
size = 19
```
[11.569]
[11.579]
```
size = 42
```

Insertion in test/Cell.hs at line 82 [11.1]

[11.2357]

      | KeyPress c <- e , isDigit c , n <- digitToInt c , n < fromEnum (maxBound :: Algo) = Right (s { algo = toEnum n } , v)

Replacement in test/Cell.hs at line 97 [11.1]

B:BD[11.2745] → [8.493:603]

      hex = foldl' (&) canvas [ write (x,y) | x <- [-size..size] , y <- [-size..size] , abs (x + y) <= size ]

[11.2745]

[11.2854]

      hex = ATGP.updatePlane (blankPlane (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 106 [11.1]

B:BD[11.3043] → [11.3043:3141]

      write :: (Int,Int) -> Draw
      write (x,y) = c %.< cell (" ·~+=≠co" !! fromEnum h) # k

[11.3043]

[11.3141]

      write :: (Int,Int) -> (Coords,ATGP.Cell)
      write (x,y) = (c , ATGP.paletteColorCell k $ ATGP.creaCell $ " ·~+=≠co" !! fromEnum h)

Replacement in test/Cell.hs at line 124 [11.1]

B:BD[11.3629] → [11.3629:4857]

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

[11.3629]

[11.4857]

         k :: Word8
            | 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

Replacement in src/Nove/Verse.hs at line 42 [4.6595]

B:BD[4.7914] → [10.3935:4065]

data Node a = Node { atom :: a , neighbours :: U.Vector Int }
data Verse a = Verse { radius :: Int , nodes :: V.Vector (Node a) }

[4.7914]

[4.7982]

data Node a = Node { ix :: Int , atom :: a }
data Verse a = Verse { radius :: Int , nodes :: V.Vector (Node a) , neighbours :: V.Vector (U.Vector Int) }

Replacement in src/Nove/Verse.hs at line 51 [4.6595]

B:BD[4.8070] → [10.4066:4108]

      , nodes = V.generate (3 * r * r) go

[4.8070]

[4.8154]

      , nodes = V.generate (3 * r * r) (\i -> Node { ix = i , atom = void })
      , neighbours = V.generate (3 * r * r) (\i -> U.generate 6 (\n -> shift Verse { radius = r } 1 (toEnum n) i))

Deletion in src/Nove/Verse.hs at line 55 [4.6595]
B:BD[4.8163] → [10.4109:4147]
∅:D[10.4147] → [3.2534:2554]
B:BD[3.2534] → [3.2534:2554]
B:BD[3.2554] → [10.4148:4240]
∅:D[10.4240] → [3.2652:2653]
B:BD[3.2652] → [3.2652:2653]
```
   go :: Int -> Node a
   go i = Node
      { atom = void
      , neighbours = U.generate 6 (\n -> shift Verse { radius = r } 1 (toEnum n) i)
      }
```

Replacement in src/Nove/Verse.hs at line 98 [4.6595]

B:BD[12.3754] → [3.2863:2907]

B:BD[3.2907] → [10.4298:4360]

neighbour :: Atom a => Node a -> Dir -> Int
neighbour n dir = U.unsafeIndex (neighbours n) (fromEnum dir)

[12.3754]

[4.9174]

neighbour :: Atom a => Verse a -> Int -> Dir -> Int
neighbour v i dir = U.unsafeIndex (V.unsafeIndex (neighbours v) i) (fromEnum dir)

Replacement in src/Nove/Logic.hs at line 25 [4.10194]

B:BD[10.5196] → [8.910:992]

   φ i = (Memo dest lock free , n' { atom = f (get v . neighbour n) $ atom n' })

[10.5196]

[10.5233]

   φ i = (Memo dest lock free , n' { atom = f (get v . ns) $ atom n' })

Insertion in src/Nove/Logic.hs at line 28 [4.10194]
[10.5246]
[10.5246]
```
      n :: Node a
```
Insertion in src/Nove/Logic.hs at line 30 [4.10194]
[10.5282]
[10.5282]
```
      ns :: Dir -> Int
      ns = neighbour v i
```

Replacement in src/Nove/Logic.hs at line 36 [4.10194]

B:BD[10.5350] → [10.5350:5434]

         | Just dir <- move $ atom n , ni <- neighbour n dir = ni : mdest (memo ni)

[10.5350]

[10.5434]

         | Just dir <- move $ atom n , ni <- ns dir = ni : mdest (memo ni)

Replacement in src/Nove/Logic.hs at line 45 [4.10194]

B:BD[10.5569] → [10.5569:5632]

            | d : _ <- mdest $ memo $ neighbour n dir = d == i

[10.5569]

[10.5632]

            | d : _ <- mdest $ memo $ ns dir = d == i

Replacement in src/Nove/Logic.hs at line 74 [4.10194]

B:BD[10.6520] → [10.6520:6603]

         | free , [dir] <- push = n { atom = get v $ neighbour n dir }  -- move in

[10.6520]

[10.6603]

         | free , [dir] <- push = n { atom = get v $ ns dir }  -- move in

Insertion in src/Nove/Cells.hs at line 7 [13.1]
[13.91]
[13.132]
```
import Data.Bool ( bool )
import Data.List ( foldl' )
```
Replacement in src/Nove/Cells.hs at line 14 [13.1]
∅:D[14.119] → [13.249:290]
∅:D[15.482] → [13.249:290]
∅:D[8.1013] → [13.249:290]
∅:D[10.6796] → [13.249:290]
B:BD[13.249] → [13.249:290]
```
   | leq > x = a
   | lgt < llt = prev a
```
[8.1013]
[13.290]
```
   | eq > x = a
   | gt < lt = prev a
```

Replacement in src/Nove/Cells.hs at line 19 [13.1]

B:BD[13.324] → [13.324:348]

B:BD[13.348] → [9.11728:11850]

   leq, lgt, llt :: Int
   leq = count (== a) adjacents
   lgt = count (> a) adjacents
   llt = count (< a) adjacents
   adjacents = ns <$> total

[13.324]

[13.421]

   -- count in one pass
   lt,eq,gt :: Int
   (lt,eq,gt) = foldl' go (0,0,0) $ ns <$> total
      where
      go (l,e,g) n
         | n < a = (succ l , e , g)
         | n > a = (l , e , succ g)
         | otherwise = (l , succ e , g)

Insertion in src/Nove/Cells.hs at line 29 [13.1]
[13.422]
[15.483]
Replacement in src/Nove/Cells.hs at line 49 [13.1]
∅:D[14.453] → [9.12174:12271]
∅:D[15.784] → [9.12174:12271]
∅:D[8.1103] → [9.12174:12271]
∅:D[10.6894] → [9.12174:12271]
B:BD[13.968] → [9.12174:12271]
```
   | count (> a) adjacents ∈ [2 :: Int] = next a
   | count (< a) adjacents ∈ [2 :: Int] = a
```
[8.1103]
[13.1051]
```
   | gt ∈ [2 :: Int] = next a
   | lt ∈ [2 :: Int] = a
```

Replacement in src/Nove/Cells.hs at line 54 [13.1]

B:BD[9.12282] → [9.12282:12310]

   adjacents = ns <$> total

[9.12282]

[13.1075]

   -- count in one pass
   (lt,gt) = foldl' go (minBound , minBound) $ ns <$> total
      where
      go (l,g) x = (bool id succ (x < a) l , bool id succ (x > a) g)

Replacement in src/Nove/Cells.hs at line 62 [13.1]

∅:D[14.563] → [9.12311:12462]

∅:D[15.886] → [9.12311:12462]

∅:D[8.1132] → [9.12311:12462]

∅:D[10.6925] → [9.12311:12462]

B:BD[13.1183] → [9.12311:12462]

   | count (== maxBound) adjacents ∈ survive , fromEnum a > n - 2 = maxBound
   | count (== maxBound) adjacents ∈ born , fromEnum a < 1 = maxBound

[8.1132]

[13.1323]

   | tops ∈ survive , fromEnum a > n - 2 = maxBound
   | tops ∈ born , fromEnum a < 1 = maxBound

Replacement in src/Nove/Cells.hs at line 68 [13.1]
B:BD[9.12473] → [9.12473:12501]
```
   adjacents = ns <$> total
```
[9.12473]
[13.1389]
```
   tops = count (== maxBound) $ ns <$> total
```

vs