jrvieira/nove - Change LDXV64JUWYYYPCV6CWMGS3EFX4ZSO7TQ6X327EOQWC5Z6W75UMXQC

vector optimized

Created by jrvieira on April 29, 2026

LDXV64JUWYYYPCV6CWMGS3EFX4ZSO7TQ6X327EOQWC5Z6W75UMXQC

Dependencies

In channels

main

Change contents

Replacement in test/Test.hs at line 98 [5.19]

B:BD[4.2190] → [4.2190:2240]

   f () _ t
      | Some m <- t = Some $ drop 1 m

[4.2190]

[4.2240]

   f () _ _ t
      | Some ds <- t = Some $ drop 1 ds

Deletion in test/Maze.hs at line 15 [7.1]
B:BD[6.330] → [6.330:357]
```
import Data.IntMap ( (!) )
```
Replacement in test/Maze.hs at line 48 [7.1]
B:BD[6.2824] → [8.262:303]
∅:D[8.303] → [6.2864:2877]
B:BD[6.2864] → [6.2864:2877]
```
   f :: () -> (Dir -> Hex) -> Hex -> Hex
   f () ns h
```
[6.2824]
[6.2877]
```
   f :: Cell () Hex
   f () m ns h
```

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

B:BD[8.812] → [3.237:414]

      | KeyPress 'r' <- e , r : rs <- seed (atom $ nodes v ! 0) = Right (s { rand = r },set (Hex { look = pick r total , seed = rs , parent = Nothing , i = 1 }) 0 (verse size))

[8.812]

[8.982]

      | KeyPress 'r' <- e , r : rs <- seed $ get v 0 = Right (s { rand = r },set (Hex { look = pick r total , seed = rs , parent = Nothing , i = 1 }) 0 (verse size))

Insertion in test/Demo.hs at line 5 [5.135]
[5.185]
[8.2799]
```
import Nove.Logic ( Memo )
```
Replacement in test/Demo.hs at line 12 [5.135]
B:BD[5.237] → [5.237:276]
```
import Data.List ( find, intersperse )
```
[5.237]
[5.276]
```
import Data.List ( intersperse )
```
Replacement in test/Demo.hs at line 14 [5.135]
B:BD[5.308] → [3.438:485]
```
import Data.IntMap as IntMap ( filter, elems )
```
[5.308]
[5.361]
```
import Data.Vector as V ( find )
```

Replacement in test/Demo.hs at line 31 [5.135]

B:BD[5.824] → [9.112:143]

B:BD[9.143] → [10.226:276]

   generate v rs = foldr ($) v
      $ set Robot { name = "@" , ops = mempty } 0

[5.824]

[11.80]

   generate v rs = sets
      [ (0                           , Robot { name = "@" , ops = mempty })

Replacement in test/Demo.hs at line 34 [5.135]

∅:D[11.81] → [10.276:533]

B:BD[10.276] → [10.276:533]

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

[11.81]

[11.82]

      , (shift v 1 U 0               , Robot { name = "t0" , ops = Move <$> cycle [U,N,L] })
      , (shift v 2 U 0               , Robot { name = "t1" , ops = Move <$> cycle [N,L,U] })
      , (shift v 1 U $ shift v 1 H 0 , Robot { name = "t2" , ops = Move <$> cycle [L,U,N] })

Replacement in test/Demo.hs at line 38 [5.135]

∅:D[11.83] → [10.533:685]

B:BD[10.533] → [10.533:685]

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

[11.83]

[11.84]

      , (shift v 8 I 0               , Robot { name = "d0" , ops = Move <$> repeat N })
      , (shift v 2 I 0               , Robot { name = "d1" , ops = Move <$> repeat I })

Replacement in test/Demo.hs at line 41 [5.135]

B:BD[11.85] → [11.85:355]

      : set Robot { name = "L0" , ops = Move <$> repeat L } (shift v 7 H $ shift v 1 I 0)
      : set Robot { name = "L1" , ops = Move <$> repeat L } (shift v 8 H $ shift v 1 I 0)
      : set Robot { name = "L2" , ops = Move <$> repeat L } (shift v 9 H $ shift v 1 I 0)

[11.85]

[11.355]

      , (shift v 7 H $ shift v 1 I 0 , Robot { name = "L0" , ops = Move <$> repeat L })
      , (shift v 8 H $ shift v 1 I 0 , Robot { name = "L1" , ops = Move <$> repeat L })
      , (shift v 9 H $ shift v 1 I 0 , Robot { name = "L2" , ops = Move <$> repeat L })

Replacement in test/Demo.hs at line 45 [5.135]

∅:D[11.356] → [10.916:1088]

B:BD[10.916] → [10.916:1088]

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

[11.356]

[11.357]

      , (shift v 2 M 0               , Robot { name = "r0" , ops = Move <$> cycle [L,H] })
      , (shift v 2 M $ shift v 1 L 0 , Robot { name = "r1" , ops = Move <$> cycle [H,L] })

Replacement in test/Demo.hs at line 48 [5.135]

∅:D[11.358] → [10.1088:1178]

B:BD[10.1088] → [10.1088:1178]

B:BD[10.1178] → [11.359:520]

      : set Robot { name = "m0" , ops = Move <$> repeat L } (shift v 5 N $ shift v 1 H 0)
      : set Robot { name = "m1" , ops = Move <$> repeat H } (shift v 5 N $ shift v 1 L 0)
      : set Robot { name = "m2" , ops = Move <$> [I] } (shift v 5 N 0)

[11.358]

[11.520]

      , (shift v 5 N $ shift v 1 H 0 , Robot { name = "m0" , ops = Move <$> repeat L })
      , (shift v 5 N $ shift v 1 L 0 , Robot { name = "m1" , ops = Move <$> repeat H })
      , (shift v 5 N 0               , Robot { name = "m2" , ops = Move <$> [I] })

Replacement in test/Demo.hs at line 52 [5.135]

B:BD[11.521] → [11.521:822]

      : set Robot { name = "p0" , ops = Move <$> repeat I } (shift v 7 L 0)
      : set Robot { name = "p1" , ops = [] } (shift v 7 L $ shift v 3 I 0)
      : set Robot { name = "p2" , ops = [] } (shift v 7 L $ shift v 5 I 0)
      : set Robot { name = "p3" , ops = [] } (shift v 7 L $ shift v 7 I 0)

[11.521]

[11.822]

      , (shift v 7 L 0               , Robot { name = "p0" , ops = Move <$> repeat I })
      , (shift v 7 L $ shift v 3 I 0 , Robot { name = "p1" , ops = [] })
      , (shift v 7 L $ shift v 5 I 0 , Robot { name = "p2" , ops = [] })
      , (shift v 7 L $ shift v 7 I 0 , Robot { name = "p3" , ops = [] })

Replacement in test/Demo.hs at line 58 [5.135]

B:BD[11.824] → [11.824:1331]

      : set Robot { name = "Tp" , ops = cycle [Move U , NoOp] } (shift v 6 H $ shift v 6 I 0)
      : set Robot { name = "Tp" , ops = cycle [Move N , NoOp] } (shift v 8 H $ shift v 9 I 0)
      : set Robot { name = "Tp" , ops = cycle [Move L , NoOp] } (shift v 9 H $ shift v 7 I 0)
      : set Robot { name = "T0" , ops = [] } (shift v 8 H $ shift v 8 I 0)
      : set Robot { name = "T1" , ops = [] } (shift v 8 H $ shift v 7 I 0)
      : set Robot { name = "T2" , ops = [] } (shift v 7 H $ shift v 7 I 0)

[11.824]

[11.1331]

      , (shift v 6 H $ shift v 6 I 0 , Robot { name = "Tp" , ops = cycle [Move U , NoOp] })
      , (shift v 8 H $ shift v 9 I 0 , Robot { name = "Tp" , ops = cycle [Move N , NoOp] })
      , (shift v 9 H $ shift v 7 I 0 , Robot { name = "Tp" , ops = cycle [Move L , NoOp] })
      , (shift v 8 H $ shift v 8 I 0 , Robot { name = "T0" , ops = [] })
      , (shift v 8 H $ shift v 7 I 0 , Robot { name = "T1" , ops = [] })
      , (shift v 7 H $ shift v 7 I 0 , Robot { name = "T2" , ops = [] })

Replacement in test/Demo.hs at line 65 [5.135]
∅:D[12.513] → [5.1382:1445]
∅:D[9.885] → [5.1382:1445]
∅:D[11.1332] → [5.1382:1445]
∅:D[10.1347] → [5.1382:1445]
B:BD[5.1382] → [5.1382:1445]
```
      : zipWith set units (flip mod (length $ nodes v) <$> rs)
```
[11.1332]
[5.1445]
```
      ] $ foldr ($) v $ zipWith set units (flip mod (length $ nodes v) <$> rs)
```
Replacement in test/Demo.hs at line 68 [5.135]
B:BD[10.1415] → [10.1415:1433]
```
   units = mempty
```
[5.1465]
[10.1433]
```
   units = replicate 7 (Box Nothing)
```

Replacement in test/Demo.hs at line 73 [5.135]

B:BD[5.1513] → [13.4:75]

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

[5.1513]

[5.1628]

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

Insertion in test/Demo.hs at line 83 [5.135]
[10.1669]
[10.1669]
```
      | Box {} <- a = push a
```

Replacement in test/Demo.hs at line 109 [5.135]

B:BD[5.2547] → [8.3158:3494]

   f :: State -> (Dir -> Unit) -> Unit -> 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 }
      | otherwise                                  = u

[5.2547]

[5.2832]

-- f :: Cell State Unit
   f :: State -> Memo -> (Dir -> Unit) -> Unit -> Unit
   f s m 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

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

B:BD[3.1055] → [3.1055:1137]

            [ scope $ take 1 $ IntMap.elems $ IntMap.filter (me . atom) $ nodes v

[3.1055]

[3.1137]

            [ scope $ V.find (me . atom) $ nodes v

Replacement in test/Demo.hs at line 232 [5.135]

B:BD[8.7010] → [3.1209:1283]

            | Just n <- find (me . atom) $ nodes v = word $ show $ atom n

[8.7010]

[8.7068]

            | Just n <- V.find (me . atom) $ nodes v = word $ show $ atom n

Replacement in test/Demo.hs at line 235 [5.135]

B:BD[12.3289] → [3.1284:1387]

      scope :: [Node Unit] -> Plane
      scope ns
         | n : _ <- ns = foldl (&) (blankPlane 5 3)

[12.3289]

[3.1387]

      scope :: Maybe (Node Unit) -> Plane
      scope mn
         | Just n <- mn = foldl (&) (blankPlane 5 3)

Replacement in test/Cell.hs at line 15 [14.1]
B:BD[14.299] → [14.299:338]
```
import Data.IntMap qualified as IntMap
```
[14.299]
[14.338]
```
import Data.Vector as V ( imap )
```

Replacement in test/Cell.hs at line 31 [14.1]

B:BD[14.621] → [3.1947:2045]

noise r v = v { nodes = IntMap.mapWithKey (\k n -> n { atom = Hex $ mod (r !! k) 8 }) $ nodes v }

[14.621]

[14.712]

noise r v = v { nodes = V.imap (\k n -> n { atom = Hex $ mod (r !! k) 8 }) $ nodes v }

Replacement in src/Nove.hs at line 4 [5.5689]
B:BD[5.5727] → [5.5727:5754]
```
import Nove.Logic ( step )
```
[5.5727]
[5.5786]
```
import Nove.Logic ( step, Memo )
```

Replacement in src/Nove.hs at line 15 [5.5689]

B:BD[5.6172] → [8.11389:11439]

type Cell state a = state -> (Dir -> a) -> a -> a

[5.6172]

[15.1479]

type Cell state a = state -> Memo -> (Dir -> a) -> a -> a

Replacement in src/Nove.hs at line 20 [5.5689]

B:BD[9.1509] → [9.1509:1578]

   Automaton g <> Automaton f = Automaton (\s ns -> g s ns . f s ns)

[9.1509]

[5.6374]

   Automaton g <> Automaton f = Automaton (\s m ns -> g s m ns . f s m ns)

Replacement in src/Nove.hs at line 23 [5.5689]
B:BD[9.1621] → [9.1621:1656]
```
   mempty = Automaton (\_ _ -> id)
```
[9.1621]
[5.6450]
```
   mempty = Automaton (\_ _ _ -> id)
```

Replacement in src/Nove/Verse.hs at line 4 [5.6595]

B:BD[5.6730] → [3.2072:2220]

import Data.IntMap as IntMap ( IntMap, fromDistinctAscList, lookup, adjust )
import Data.Vector.Unboxed as Vector ( Vector, unsafeIndex, generate )

[5.6730]

import Data.Vector as V ( Vector, unsafeIndex, generate, unsafeUpd )
import Data.Vector.Unboxed as U ( Vector, unsafeIndex, generate )

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

B:BD[5.7914] → [3.2221:2347]

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

[5.7914]

[5.7982]

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

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

B:BD[5.8070] → [3.2395:2476]

      , nodes = IntMap.fromDistinctAscList $ take (3 * r * r) $ mkNode <$> [0..]

[5.8070]

[5.8154]

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

Replacement in src/Nove/Verse.hs at line 54 [5.6595]

B:BD[5.8163] → [3.2477:2534]

   mkNode :: Int -> (Int,Node a)
   mkNode i = (i , Node

[5.8163]

[3.2534]

   go :: Int -> Node a
   go i = Node

Replacement in src/Nove/Verse.hs at line 57 [5.6595]

B:BD[3.2554] → [3.2554:2652]

      , neighbours = Vector.generate 6 (\n -> shift Verse { radius = r } 1 (toEnum n) i)
      })

[3.2554]

[3.2652]

      , neighbours = U.generate 6 (\n -> shift Verse { radius = r } 1 (toEnum n) i)
      }

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

B:BD[3.2699] → [3.2699:2770]

node v i = maybe (Node { atom = void }) id $ IntMap.lookup i (nodes v)

[3.2699]

[3.2770]

node v = V.unsafeIndex (nodes v)

Replacement in src/Nove/Verse.hs at line 101 [5.6595]
B:BD[3.2808] → [3.2808:2862]
```
get v i = maybe void atom $ IntMap.lookup i (nodes v)
```
[3.2808]
[12.3753]
```
get v = atom . node v
```

Replacement in src/Nove/Verse.hs at line 104 [5.6595]

B:BD[3.2907] → [3.2907:2974]

neighbour n dir = Vector.unsafeIndex (neighbours n) (fromEnum dir)

[3.2907]

[5.9174]

neighbour n dir = U.unsafeIndex (neighbours n) (fromEnum dir)

Replacement in src/Nove/Verse.hs at line 109 [5.6595]

B:BD[5.9299] → [3.2975:3059]

upd f i v = v { nodes = IntMap.adjust (\n -> n { atom = f $ atom n }) i $ nodes v }

[5.9299]

[5.9353]

upd f i v = v { nodes = V.unsafeUpd (nodes v) [(i , n { atom = f $ atom n })] }
   where
   n = node v i

Insertion in src/Nove/Verse.hs at line 117 [5.6595]

[5.9457]

sets :: Atom a => [(Int, a)] -> Verse a -> Verse a
sets ss v = v { nodes = V.unsafeUpd (nodes v) [ (i , (node v i) { atom = a }) | (i,a) <- ss ] }

Replacement in src/Nove/Logic.hs at line 6 [5.10194]

B:BD[3.3105] → [3.3105:3192]

B:BD[3.3884] → [3.3885:4158]

B:BD[10.5128] → [3.3884:3884]

∅:D[3.3882] → [10.5078:5128]

B:BD[10.5078] → [10.5078:5128]

B:BD[10.4796] → [3.3608:3882]

B:BD[7.1528] → [10.4703:4796]

∅:D[9.2451] → [7.1527:1528]

∅:D[10.4702] → [7.1527:1528]

B:BD[7.1527] → [7.1527:1528]

∅:D[3.3607] → [10.4375:4702]

B:BD[10.4375] → [10.4375:4702]

B:BD[10.4328] → [3.3553:3607]

∅:D[3.3552] → [10.4252:4328]

B:BD[10.4252] → [10.4252:4328]

B:BD[10.4189] → [3.3489:3552]

∅:D[3.3488] → [10.4054:4189]

B:BD[10.4054] → [10.4054:4189]

B:BD[10.3978] → [3.3402:3488]

∅:D[3.3401] → [10.3898:3978]

B:BD[10.3898] → [10.3898:3978]

B:BD[5.12171] → [3.3285:3401]

∅:D[9.2343] → [5.12170:12171]

B:BD[5.12170] → [5.12170:12171]

B:BD[5.11371] → [9.2270:2343]

∅:D[9.2269] → [5.11370:11371]

∅:D[10.3796] → [5.11370:11371]

B:BD[5.11370] → [5.11370:11371]

B:BD[5.10628] → [10.3697:3796]

∅:D[9.2102] → [5.10618:10628]

∅:D[3.3284] → [5.10618:10628]

∅:D[10.3696] → [5.10618:10628]

∅:D[16.4039] → [5.10618:10628]

∅:D[8.11676] → [5.10618:10628]

B:BD[5.10618] → [5.10618:10628]

B:BD[8.11614] → [3.3193:3284]

B:BD[5.10514] → [8.11541:11614]

B:BD[5.10489] → [5.10489:10514]

∅:D[10.3634] → [5.10426:10427]

B:BD[5.10426] → [5.10426:10427]

B:BD[5.10426] → [10.3565:3634]

∅:D[7.626] → [5.10394:10426]

∅:D[9.2069] → [5.10394:10426]

∅:D[10.3564] → [5.10394:10426]

∅:D[12.3986] → [5.10394:10426]

B:BD[5.10394] → [5.10394:10426]

∅:D[3.3192] → [10.3516:3564]

B:BD[9.2069] → [10.3516:3564]

∅:D[3.4158] → [9.1912:1913]

B:BD[5.10238] → [9.1912:1913]

import Data.IntMap.Strict as IntMap ( IntMap, (!), foldrWithKey, fromDistinctAscList )
      n' :: Node a
         | free , [dir] <- push = n { atom = get v $ neighbour n dir }  -- move in
         | free , null push = n { atom = void }  -- clear
         | not free , d : _ <- dest , free' $ memo ! d = n { atom = void }  -- move out
         | otherwise = n
         | otherwise = True
      -- update atom
         | Just ni <- loop , i /= ni = False  -- ρ tail
         | Just ni <- loop , i == ni = dest !! 1 /= i && not (any (lock' . (memo !)) $ takeWhile (/= i) dest)  -- closed loop
         | ni : _ <- dest = free' $ memo ! ni  -- linear (loops ruled out, recurse freely)
      -- neighbours are free to move in
      free :: Bool
         | lock = False  -- 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
         | mass $ atom n , null dest = True  -- block
            | otherwise = False
      -- stops movement
      lock :: Bool
            | d : _ <- dest' $ memo ! neighbour n dir = d == i
         | otherwise = []
      -- want to move here
      push :: [Dir]
      push = filter π total
         where
         π dir
         | Just dir <- move $ atom n , ni <- neighbour n dir = ni : dest' (memo ! ni)
      where
      -- chain of destinations (memory shared)
      dest :: [Int]
   φ :: Int -> Node a -> ([Memo], [Node a]) -> ([Memo], [Node a])
   φ i n = bimap (Memo dest lock free :) (n' :)
   intmap :: [v] -> IntMap v
   intmap = fromDistinctAscList . zip [0..]
   -- fold with future
   (,) memo nodes' = bimap intmap intmap $ foldrWithKey φ mempty $ nodes v
   where
step f !v = v { nodes = (\n -> n { atom = f (get v . neighbour n) $ atom n }) <$> nodes' }
step :: forall a. Atom a => ((Dir -> a) -> a -> a) -> Verse a -> Verse a
-- | Step in simulation
data Memo = Memo { dest' :: [Int] , lock' :: Bool , free' :: Bool }
import Data.Bifunctor ( bimap )
import Data.IntSet as IntSet ( member, insert )

[3.3105]

import Data.Vector as V ( Vector, generate, unsafeIndex, length, map )
import Data.IntSet as IntSet ( member, insert )
data Memo = Memo { mdest :: [Int] , mlock :: Bool , mfree :: Bool }
-- | Step in simulation
step :: forall a. Atom a => (Memo -> (Dir -> a) -> a -> a) -> Verse a -> Verse a
step f v = v { nodes = V.map (\(m,n) -> n { atom = f m (get v . neighbour n) $ atom n }) result }
   where
   result :: V.Vector (Memo,Node a)
   result = V.generate (V.length $ nodes v) φ
   memo :: Int -> Memo
   memo = fst . V.unsafeIndex result
   φ :: Int -> (Memo,Node a)
   φ i = (Memo dest lock free , n')
      where
      n = V.unsafeIndex (nodes v) i
      -- chain of destinations (memory shared)
      dest :: [Int]
         | Just dir <- move $ atom n , ni <- neighbour n dir = ni : mdest (memo ni)
         | otherwise = []
      -- want to move here
      push :: [Dir]
      push = filter π total
         where
         π dir
            | d : _ <- mdest $ memo $ neighbour n dir = d == i
            | otherwise = False
      -- stops movement
      lock :: Bool
         | mass $ atom n , 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
      -- neighbours are free to move in
      free :: Bool
         | lock = False  -- block
         | Just ni <- loop , i /= ni = False  -- ρ tail
         | Just ni <- loop , i == ni = dest !! 1 /= i && not (any (mlock . memo) $ takeWhile (/= i) dest)  -- closed loop
         | ni : _ <- dest = mfree $ memo ni  -- linear (loops ruled out, recurse freely)
         | otherwise = True
      -- update atom
      n' :: Node a
         | free , [dir] <- push = n { atom = get v $ neighbour n dir }  -- move in
         | free , null push = n { atom = void }  -- clear
         | not free , d : _ <- dest , mfree $ memo d = n { atom = void }  -- move out
         | otherwise = n

Replacement in src/Nove/Cells.hs at line 10 [15.1]
B:BD[2.466] → [2.466:482]
```
terra x () ns a
```
[2.466]
[15.249]
```
terra x () m ns a
```
Replacement in src/Nove/Cells.hs at line 23 [15.1]
B:BD[2.531] → [2.531:545]
```
waves () ns a
```
[2.531]
[8.11851]
```
waves () m ns a
```

Replacement in src/Nove/Cells.hs at line 28 [15.1]

B:BD[2.595] → [2.595:641]

pulse () ns a = prev $ maximum $ ns <$> total

[2.595]

[15.652]

pulse () m ns a = prev $ maximum $ ns <$> total

Replacement in src/Nove/Cells.hs at line 31 [15.1]
B:BD[2.703] → [2.703:716]
```
dois () ns a
```
[2.703]
[8.11962]
```
dois () m ns a
```
Replacement in src/Nove/Cells.hs at line 40 [15.1]
B:BD[2.771] → [2.771:784]
```
bees () ns a
```
[2.771]
[8.12174]
```
bees () m ns a
```
Replacement in src/Nove/Cells.hs at line 49 [15.1]
B:BD[2.858] → [2.858:886]
```
gene survive born n () ns a
```
[2.858]
[8.12311]
```
gene survive born n () m ns a
```
Deletion in nove.cabal at line 27 [5.12206]
B:BD[5.12642] → [5.12642:12671]
```
      , unordered-containers
```
Deletion in nove.cabal at line 28 [5.12206]
∅:D[3.4179] → [5.12671:12688]
B:BD[5.12671] → [5.12671:12688]
```
      , hashable
```
Replacement in nove.cabal at line 49 [5.12206]
B:BD[5.13047] → [5.13047:13066]
```
      , containers
```
[5.13047]
[5.13066]
```
      , vector
```
Deletion in nove.cabal at line 51 [5.12206]
B:BD[5.13093] → [3.4180:4202]
```
      , ansi-terminal
```
Deletion in nove.cabal at line 62 [5.12206]
B:BD[15.1754] → [15.1754:1773]
```
      , containers
```
Replacement in nove.cabal at line 75 [5.12206]
B:BD[6.3871] → [6.3871:3890]
```
      , containers
```
[6.3871]
[6.3890]
```
      , vector
```

vector optimized

Dependencies

In channels

Change contents

Replacement in test/Test.hs at line 98 [5.19]

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

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

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

Insertion in test/Demo.hs at line 5 [5.135]

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

Replacement in test/Demo.hs at line 14 [5.135]

Replacement in test/Demo.hs at line 31 [5.135]

Replacement in test/Demo.hs at line 34 [5.135]

Replacement in test/Demo.hs at line 38 [5.135]

Replacement in test/Demo.hs at line 41 [5.135]

Replacement in test/Demo.hs at line 45 [5.135]

Replacement in test/Demo.hs at line 48 [5.135]

Replacement in test/Demo.hs at line 52 [5.135]

Replacement in test/Demo.hs at line 58 [5.135]

Replacement in test/Demo.hs at line 65 [5.135]

Replacement in test/Demo.hs at line 68 [5.135]

Replacement in test/Demo.hs at line 73 [5.135]

Insertion in test/Demo.hs at line 83 [5.135]

Replacement in test/Demo.hs at line 109 [5.135]

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

Replacement in test/Demo.hs at line 232 [5.135]

Replacement in test/Demo.hs at line 235 [5.135]

Replacement in test/Cell.hs at line 15 [14.1]

Replacement in test/Cell.hs at line 31 [14.1]

Replacement in src/Nove.hs at line 4 [5.5689]

Replacement in src/Nove.hs at line 15 [5.5689]

Replacement in src/Nove.hs at line 20 [5.5689]

Replacement in src/Nove.hs at line 23 [5.5689]

Replacement in src/Nove/Verse.hs at line 4 [5.6595]

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

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

Replacement in src/Nove/Verse.hs at line 54 [5.6595]

Replacement in src/Nove/Verse.hs at line 57 [5.6595]

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

Replacement in src/Nove/Verse.hs at line 101 [5.6595]

Replacement in src/Nove/Verse.hs at line 104 [5.6595]

Replacement in src/Nove/Verse.hs at line 109 [5.6595]

Insertion in src/Nove/Verse.hs at line 117 [5.6595]

Replacement in src/Nove/Logic.hs at line 6 [5.10194]

Replacement in src/Nove/Cells.hs at line 10 [15.1]

Replacement in src/Nove/Cells.hs at line 23 [15.1]

Replacement in src/Nove/Cells.hs at line 28 [15.1]

Replacement in src/Nove/Cells.hs at line 31 [15.1]

Replacement in src/Nove/Cells.hs at line 40 [15.1]

Replacement in src/Nove/Cells.hs at line 49 [15.1]

Deletion in nove.cabal at line 27 [5.12206]

Deletion in nove.cabal at line 28 [5.12206]

Replacement in nove.cabal at line 49 [5.12206]

Deletion in nove.cabal at line 51 [5.12206]

Deletion in nove.cabal at line 62 [5.12206]

Replacement in nove.cabal at line 75 [5.12206]