jrvieira/nove - Change RIB2JXPMZHC5XCLGB7Q425PVNJPHMWPJSLMR2GTFLD474WB72ZHAC

vs

Created by jrvieira on April 11, 2026

RIB2JXPMZHC5XCLGB7Q425PVNJPHMWPJSLMR2GTFLD474WB72ZHAC

Dependencies

In channels

main

Change contents

Replacement in test/Maze.hs at line 44 [4.1]
B:BD[3.1035] → [2.23:44]
```
   move = const Free
```
[3.1035]
[3.1080]
```
   mass = const True
   move = const Nothing
```

Replacement in test/Demo.hs at line 12 [7.135]

B:BD[5.117] → [6.3:60]

import Data.Map as Map ( Map, (!), filterWithKey, keys )

[5.117]

[7.361]

import Data.Map as Map ( Map, (!) )

Replacement in test/Demo.hs at line 24 [7.135]

B:BD[8.150] → [8.150:271]

      gInitState = (State { rand = r , center = 0 , input = (Nothing,mempty) , mode = Full } , generate (verse 11) rs) ,

[8.150]

[7.705]

      gInitState = (State { rand = r , center = 0 , input = (Nothing , mempty) , mode = Full , play = False } , generate (verse 11) rs) ,

Replacement in test/Demo.hs at line 32 [7.135]

B:BD[2.143] → [2.143:885]

      $ set Robot { name = "@" , go = mempty } 0
      : set Robot { name = "t0" , go = Move <$> cycle [U,N,L] } (shift v 1 U 0)
      : set Robot { name = "t1" , go = Move <$> cycle [N,L,U] } (shift v 2 U 0)
      : set Robot { name = "t2" , go = Move <$> cycle [L,U,N] } (shift v 1 U $ shift v 1 H 0)
      : set Robot { name = "i" , go = Move <$> repeat N } (shift v 8 I 0)
      : set Robot { name = "n" , go = Move <$> repeat I } (shift v 2 I 0)
      : set Robot { name = "x" , go = mempty } (shift v 7 M 0)
      : set Robot { name = "L0" , go = Move <$> repeat L } (shift v 17 H 0)
      : set Robot { name = "L1" , go = Move <$> repeat L } (shift v 18 H 0)
      : set Robot { name = "L2" , go = Move <$> repeat L } (shift v 19 H 0)

[2.143]

[7.1382]

      $ set Robot { name = "@" , ops = mempty } 0
      : set Robot { name = "t0" , ops = Move <$> cycle [U,N,L] } (shift v 1 U 0)
      : set Robot { name = "t1" , ops = Move <$> cycle [N,L,U] } (shift v 2 U 0)
      : set Robot { name = "t2" , ops = Move <$> cycle [L,U,N] } (shift v 1 U $ shift v 1 H 0)
      : set Robot { name = "d0" , ops = Move <$> repeat N } (shift v 8 I 0)
      : set Robot { name = "d1" , ops = Move <$> repeat I } (shift v 2 I 0)
      : set Robot { name = "L0" , ops = Move <$> repeat L } (shift v 17 H 0)
      : set Robot { name = "L1" , ops = Move <$> repeat L } (shift v 18 H 0)
      : set Robot { name = "L2" , ops = Move <$> repeat L } (shift v 19 H 0)
      : set Robot { name = "r0" , ops = Move <$> cycle [L,H] } (shift v 2 M 0)
      : set Robot { name = "r1" , ops = Move <$> cycle [H,L] } (shift v 2 M $ shift v 1 L 0)
      : set Robot { name = "m0" , ops = Move <$> repeat L } (shift v 5 N $ shift v 1 H 0)
      : set Robot { name = "m2" , ops = Move <$> repeat H } (shift v 5 N $ shift v 1 L 0)
      : set Robot { name = "m1" , ops = Move <$> cycle [I,N] } (shift v 5 N 0)

Replacement in test/Demo.hs at line 49 [7.135]

B:BD[7.1465] → [2.886:953]

   units = replicate 4 Wall <> replicate 6 Box <> replicate 6 Ball

[7.1465]

[7.1512]

-- units = replicate 4 Wall <> replicate 6 Box <> replicate 6 Ball
   units = mempty
data Op = Move Dir
   deriving Show

Replacement in test/Demo.hs at line 55 [7.135]

B:BD[7.1513] → [2.954:1033]

data Unit = None | Wall | Box | Ball | Robot { name :: String , go :: [Move] }

[7.1513]

[7.1628]

data Unit = None | Wall | Box | Ball | Robot { name :: String , ops :: [Op] }

Insertion in test/Demo.hs at line 60 [7.135]

[7.1686]

   mass a
      | None <- a = False
      | otherwise = True

Replacement in test/Demo.hs at line 64 [7.135]

B:BD[7.1696] → [2.1034:1126]

      | Robot {} <- a , m : _ <- go a = m
      | Wall <- a = Lock
      | otherwise = None

[7.1696]

[8.829]

      | Robot {} <- a , Move dir : _ <- ops a = Just dir
      | otherwise = Nothing

Insertion in test/Demo.hs at line 74 [7.135]
[8.873]
[7.1962]
```
   , play :: Bool
```

Replacement in test/Demo.hs at line 80 [7.135]

B:BD[7.2055] → [7.2055:2090]

B:BD[7.2090] → [5.553:615]

logic _ _ (KeyPress 'q') = Left ()
logic _ (s,v) (KeyPress k) = Right (s { input = input' } , v)

[7.2055]

[7.2150]

logic g (s,v) e
   | KeyPress 'q'  <- e = Left ()
   | KeyPress 'p'  <- e = Right (s { play = True } , v)
   | KeyPress 'P'  <- e = Right (s { play = False } , 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)

Replacement in test/Demo.hs at line 91 [7.135]

B:BD[7.2193] → [5.616:653]

   input' :: (Maybe Char,Queue Char)

[7.2193]

[6.304]

   input' :: Char -> (Maybe Char,Queue Char)
   input' k

Deletion in test/Demo.hs at line 95 [7.135]
∅:D[5.760] → [7.2333:2334]
B:BD[7.2333] → [7.2333:2334]
B:BD[7.2334] → [8.874:922]
∅:D[8.922] → [7.2393:2402]
B:BD[7.2393] → [7.2393:2402]
```
logic _ (s,v) Tick = Right (s' , sim demo s' v)
   where
```

Replacement in test/Demo.hs at line 97 [7.135]

B:BD[7.2417] → [5.761:894]

      | Just (c,q) <- dequeue (snd $ input s) = s { input = (Just c , q) }
      | otherwise = s { input = (Nothing,snd $ input s) }

[7.2417]

[7.2546]

      | Just (c,q) <- dequeue $ snd $ input s = s { input = (Just c , q) }
      | otherwise = s { input = (Nothing , snd $ input s) }

Insertion in test/Demo.hs at line 105 [7.135]

[7.2810]

      | Just 'c' <- k = z { mode = Dumb }
      | Just 'C' <- k = z { mode = Full }

Replacement in test/Demo.hs at line 203 [7.135]

B:BD[8.1585] → [8.1585:1648]

      | Dumb <- mode s , Nothing <- move a = color Black Vivid

[8.1585]

[8.1648]

      | Dumb <- mode s , not (mass a) = color Black Vivid

Replacement in test/Demo.hs at line 207 [7.135]

B:BD[8.1875] → [8.1875:2103]

      | Dumb <- mode s , Robot {} <- a , "n"   <- name a = color Yellow Dull
      | Dumb <- mode s , Robot {} <- a , "i"   <- name a = color Green Dull
      | Dumb <- mode s , Robot {} <- a , 'L':_ <- name a = color Cyan Dull

[8.1875]

[8.2103]

      | Dumb <- mode s , Robot {} <- a , "d0"   <- name a = color Yellow Dull
      | Dumb <- mode s , Robot {} <- a , "d1"  <- name a = color Green Dull
      | Dumb <- mode s , Robot {} <- a , 'L':_<- name a = color Cyan Dull
      | Dumb <- mode s , Robot {} <- a , "r0"  <- name a = color White Vivid
      | Dumb <- mode s , Robot {} <- a , "r1"  <- name a = color Black Vivid

Replacement in test/Demo.hs at line 215 [7.135]

B:BD[8.2224] → [8.2224:2314]

      | Full <- mode s , Nothing <- move a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666

[8.2224]

[8.2314]

      | Full <- mode s , not (mass a) = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666

Replacement in test/Demo.hs at line 219 [7.135]

B:BD[8.2626] → [8.2626:2834]

      | Full <- mode s , Robot {} <- a , "n"   <- name a = rgbColor $ sRGB24 0x99 0x99 0x66  -- #999966
      | Full <- mode s , Robot {} <- a , "i"   <- name a = rgbColor $ sRGB24 0x66 0x99 0x66  -- #669966

[8.2626]

[8.2834]

      | Full <- mode s , Robot {} <- a , "d0"  <- name a = rgbColor $ sRGB24 0x99 0x99 0x66  -- #999966
      | Full <- mode s , Robot {} <- a , "d1"  <- name a = rgbColor $ sRGB24 0x66 0x99 0x66  -- #669966

Insertion in test/Demo.hs at line 222 [7.135]

[8.2938]

      | Full <- mode s , Robot {} <- a , "r0"  <- name a = rgbColor $ sRGB24 0x99 0x99 0x99  -- #999999
      | Full <- mode s , Robot {} <- a , "r1"  <- name a = rgbColor $ sRGB24 0x66 0x66 0x66  -- #666666

Deletion in src/Nove/Verse.hs at line 35 [7.6595]
B:BD[2.1834] → [2.1834:1870]
```
data Move = Free | Lock | Move Dir
```

Replacement in src/Nove/Verse.hs at line 38 [7.6595]

B:BD[7.7848] → [2.1871:1910]

   move :: a -> Move  -- wants to move

[7.7848]

[7.7913]

   mass :: a -> Bool
   move :: a -> Maybe Dir  -- wants to move

Replacement in src/Nove/Logic.hs at line 5 [7.10194]

B:BD[2.1913] → [2.1913:1933]

∅:D[2.1933] → [7.10238:10239]

B:BD[7.10238] → [7.10238:10239]

B:BD[7.10239] → [4.533:562]

B:BD[4.562] → [2.1934:2038]

import Zero ( (#) )
import Zero ( total, floyd )
import Data.IntMap as IntMap ( IntMap, (!), mapWithKey, foldrWithKey, mapWithKey, fromDistinctAscList )

[2.1913]

[2.2038]

import Zero ( total )
import Data.IntMap as IntMap ( IntMap, (!), mapWithKey, foldrWithKey, fromDistinctAscList )

Insertion in src/Nove/Logic.hs at line 8 [7.10194]
[2.2069]
[7.10394]
```
import Data.IntSet as IntSet ( member, insert )
```

Insertion in src/Nove/Logic.hs at line 10 [7.10194]

[7.10426]


data Memo = Memo { dest' :: [Int] , lock' :: Bool , free' :: Bool }

Replacement in src/Nove/Logic.hs at line 16 [7.10194]
B:BD[7.10586] → [2.2070:2102]
```
step f v = v { nodes = nodes' }
```
[7.10586]
[7.10618]
```
step f v = v { nodes = mapWithKey (f . adjacents v) nodes' }
```

Replacement in src/Nove/Logic.hs at line 19 [7.10194]

B:BD[7.10628] → [2.2103:2153]

∅:D[2.2153] → [7.10628:10659]

∅:D[8.4087] → [7.10628:10659]

B:BD[7.10628] → [7.10628:10659]

B:BD[7.10659] → [2.2154:2269]

   ms :: IntMap (Maybe Dir)
   nodes' :: IntMap a
   -- fold go with future memo
   (ms,nodes') = bimap intmap intmap $ foldrWithKey go mempty $ nodes v
   -- ms: future memory of movement intent

[7.10628]

[7.11370]

   -- fold with future
   (,) memo nodes' = bimap intmap intmap $ foldrWithKey φ mempty $ nodes v

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

B:BD[7.12171] → [2.2344:2451]

   go :: Int -> a -> ([Maybe Dir], [a]) -> ([Maybe Dir], [a])
   go i a = bimap id (f (adjacents v i) a :)

[7.12171]

[4.1527]

   φ :: Int -> a -> ([Memo], [a]) -> ([Memo], [a])
   φ i a = bimap (Memo dest lock free :) (a' :)
      where
      -- chain of destinations (memory shared)
      dest :: [Int]
         | Just dir <- move a , n <- shift v 1 dir i = n : dest' (memo ! n)
         | otherwise = []
      -- want to move here
      push :: [Dir]
      push = filter π total
         where
         π dir
            | d : _ <- dest' $ memo ! shift v 1 dir i = d == i
            | otherwise = False
      -- stops movement
      lock :: Bool
         | mass a , null dest = True  -- block
         | not . null $ drop 1 push = True  -- stall on dispute
         | otherwise = False
      -- find loop at element x
      loop :: Maybe Int
      loop = λ mempty (i : dest)
         where
         λ _ [] = Nothing
         λ s (x:xs)
            | member x s = Just x
            | otherwise = λ (insert x s) xs

Insertion in src/Nove/Logic.hs at line 59 [7.10194]

[4.1528]

      -- neighbours are free to move in
      free :: Bool
         | lock = False  -- block
         | Just n <- loop , i /= n = False  -- ρ tail || reciprocal
         | Just n <- loop , i == n = dest !! 1 /= i && not (any (lock' . (memo !)) $ takeWhile (/= i) dest)  -- closed loop
         | n : _ <- dest = free' $ memo ! n  -- linear (loops ruled out, recurse freely)
         | otherwise = True
      -- update atom
      a' :: a
         | free , [dir] <- push = node v $ shift v 1 dir i
         | free , null push = void
         | not free , d : _ <- dest , free' (memo ! d) = void
         | otherwise = a

vs