typo fix with Claude Code

Author: toyboot4e

src/AtCoder/Extra/DynLazySegTree/Raw.hs

@@ -56,7 +56,7 @@ import GHC.Stack (HasCallStack)
 import Prelude hiding (read)
 
 -- | A dynamic, lazily propagated segment tree that covers a half-open interval \([l_0, r_0)\).
--- The nodes are instantinated as needed.
+-- The nodes are instantiated as needed.
 --
 -- @since 1.2.1.0
 data DynLazySegTree s f a = DynLazySegTree
@@ -170,7 +170,7 @@ newSeqST dst@DynLazySegTree {..} !xs = do
 {-# INLINE newNodeInST #-}
 newNodeInST :: (HasCallStack, Monoid f, VU.Unbox f, Monoid a, VU.Unbox a) => DynLazySegTree s f a -> Int -> Int -> ST s P.Index
 newNodeInST dst@DynLazySegTree {initialProdLdst} l r = do
-  let !_ = ACIA.runtimeAssert (r > l) $ "AtCoder.Extra.DynLazySegTree.Raw.nodeNodeInST: not empty or negative interval: " ++ show (l, r)
+  let !_ = ACIA.runtimeAssert (r > l) $ "AtCoder.Extra.DynLazySegTree.Raw.newNodeInST: not empty or negative interval: " ++ show (l, r)
   newNodeST dst $! initialProdLdst l r
 
 -- | \(O(\log L)\)
@@ -397,7 +397,7 @@ resetIntervalST dst@DynLazySegTree {..} root ql0 qr0
   | ql0 == qr0 = pure root
   | P.nullIndex root = pure P.undefIndex
   | ql0 == l0Ldst && qr0 == r0Ldst = do
-      -- for the case of non-persistent segment tere, we should update the root in-place:
+      -- for the case of non-persistent segment tree, we should update the root in-place:
       root' <- cloneOnWriteST dst root
       VGM.write xLdst (coerce root') $! initialProdLdst l0Ldst r0Ldst
       VGM.write lLdst (coerce root') P.undefIndex

src/AtCoder/Extra/DynSegTree.hs

@@ -92,7 +92,7 @@ new ::
   Int ->
   -- | Right index boundary \(r_0\)
   Int ->
-  -- | Dynamic propagated segment tree
+  -- | Dynamic segment tree
   m (Raw.DynSegTree (PrimState m) a)
 new nDst l r = stToPrim $ Raw.newST False nDst l r (\_ _ -> mempty)
 

src/AtCoder/Extra/DynSegTree/Raw.hs

@@ -156,7 +156,7 @@ newSeqST dst@DynSegTree {..} !xs = do
 {-# INLINE newNodeInST #-}
 newNodeInST :: (HasCallStack, Monoid a, VU.Unbox a) => DynSegTree s a -> Int -> Int -> ST s P.Index
 newNodeInST dst@DynSegTree {initialProdDst} l r = do
-  let !_ = ACIA.runtimeAssert (r > l) $ "AtCoder.Extra.DynSegTree.Raw.nodeNodeInST: not empty or negative interval: " ++ show (l, r)
+  let !_ = ACIA.runtimeAssert (r > l) $ "AtCoder.Extra.DynSegTree.Raw.newNodeInST: not empty or negative interval: " ++ show (l, r)
   newNodeST dst $! initialProdDst l r
 
 -- | \(O(\log L)\)
@@ -257,7 +257,7 @@ resetIntervalST dst@DynSegTree {..} root ql0 qr0
   | ql0 == qr0 = pure root
   | P.nullIndex root = pure P.undefIndex
   | ql0 == l0Dst && qr0 == r0Dst = do
-      -- for the case of non-persistent segment tere, we should update the root in-place:
+      -- for the case of non-persistent segment tree, we should update the root in-place:
       root' <- cloneOnWriteST dst root
       VGM.write xDst (coerce root') $! initialProdDst l0Dst r0Dst
       VGM.write lDst (coerce root') P.undefIndex

src/AtCoder/Extra/DynSparseSegTree.hs

@@ -3,8 +3,8 @@
 {-# LANGUAGE TypeFamilies #-}
 
 -- | A dynamic, sparse segment tree that covers a half-open interval \([l_0, r_0)\). Nodes are
--- instantinated as needed, with the required capacity being \(q\), where \(q\) is the number of
--- mutable operations. The traid-off compared to the non-sparse variant is that initial monoid
+-- instantiated as needed, with the required capacity being \(q\), where \(q\) is the number of
+-- mutable operations. The trade-off compared to the non-sparse variant is that initial monoid
 -- values are fixed at `mempty`.
 --
 -- ==== __Example__
@@ -189,7 +189,7 @@ maxRightM dst (P.Handle handle) f = do
   root <- VGM.read handle 0
   Raw.maxRightM dst root f
 
--- | \(O(\log L)\) Claers all the nodes from the storage.
+-- | \(O(\log L)\) Clears all the nodes from the storage.
 --
 -- @since 1.2.2.0
 {-# INLINE clear #-}

src/AtCoder/Extra/DynSparseSegTree/Persistent.hs

@@ -2,9 +2,9 @@
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE TypeFamilies #-}
 
--- | A dynamic, sparse, persitent segment tree that covers a half-open interval \([l_0, r_0)\). Nodes are
--- instantinated as needed, with the required capacity being \(2q \log_2 L\), where \(q\) is the number of
--- mutable operations. The traid-off compared to the non-sparse variant is that initial monoid
+-- | A dynamic, sparse, persistent segment tree that covers a half-open interval \([l_0, r_0)\). Nodes are
+-- instantiated as needed, with the required capacity being \(2q \log_2 L\), where \(q\) is the number of
+-- mutable operations. The trade-off compared to the non-sparse variant is that initial monoid
 -- values are fixed at `mempty`.
 --
 -- ==== __Example__
@@ -172,7 +172,7 @@ maxRightM :: (HasCallStack, PrimMonad m, Monoid a, VU.Unbox a) => Raw.DynSparseS
 maxRightM dst root f = do
   Raw.maxRightM dst root f
 
--- | \(O(\log L)\) Claers all the nodes from the storage.
+-- | \(O(\log L)\) Clears all the nodes from the storage.
 --
 -- @since 1.2.2.0
 {-# INLINE clear #-}

src/AtCoder/Extra/DynSparseSegTree/Raw.hs

@@ -44,8 +44,8 @@ import Data.Vector.Unboxed.Mutable qualified as VUM
 import GHC.Stack (HasCallStack)
 import Prelude hiding (read)
 
--- | A dynamic, sparse segment tree that covers a half-open interval \([l_0, r_0)\). Is is dynamic
--- in that the nodes are instantinated as needed.
+-- | A dynamic, sparse segment tree that covers a half-open interval \([l_0, r_0)\). It is dynamic
+-- in that the nodes are instantiated as needed.
 --
 -- @since 1.2.1.0
 data DynSparseSegTree s a = DynSparseSegTree

src/AtCoder/Extra/Graph.hs

@@ -379,7 +379,7 @@ findCycleUndirected gr@Csr {..} =
       -- This is not optimal, but we need a dedicated `buildUndirected` function and different edge ID
       -- (not index) handling in CSR if we go with the optimal approach.
       --
-      --  Note that the implementations are suspecious..
+      --  Note that the implementations are suspicious..
       findCycleComplexUndirected gr <|> findCycleSimpleUndirected gr
 
 {-# INLINEABLE findCycleComplexUndirected #-}
@@ -473,7 +473,7 @@ findCycleSimpleUndirected gr@Csr {..} = runST $ do
   es <- GV.new @_ @Int 16
   dep' <- VU.unsafeFreeze dep
 
-  -- Find edge with minimum depth difference, which makes up a loop (not used in the DFS forets):
+  -- Find edge with minimum depth difference, which makes up a loop (not used in the DFS forests):
   minLen <- VUM.replicate 1 (maxBound `div` 2 :: Int)
   backE <- VUM.replicate 1 (-1 :: Int, -1 :: Int)
   for_ [0 .. nCsr - 1] $ \vA -> do
@@ -1308,7 +1308,7 @@ bellmanFordImpl {- !policy -} !trackPrev !nVerts !gr !undefW !sources = runST $
       VGM.write dist v w
   updated <- VUM.replicate 1 False
 
-  -- look around adjaenct vertices
+  -- look around adjacent vertices
   let update v1 = do
         d1 <- VGM.read dist v1
         when (d1 /= undefW) $ do
@@ -1603,7 +1603,7 @@ updateEdgeFloydWarshall mat nVerts undefW a b w = do
   prev <- VUM.replicate @_ @Int 0 (-1 :: Int)
   stToPrim $ updateEdgeFloydWarshallST False mat prev nVerts undefW a b w
 
--- | \(O(n^2)\) Updates distance matrix of Floyd–Warshall on edge weight chaneg or new edge addition.
+-- | \(O(n^2)\) Updates distance matrix of Floyd–Warshall on edge weight change or new edge addition.
 --
 -- ==== Constraints
 -- - \(n \ge 1\)

src/AtCoder/Extra/HashMap.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE RecordWildCards #-}
 
--- original implementaion:
+-- original implementation:
 -- <https://github.com/maspypy/library/blob/main/ds/hashmap.hpp>
 
 -- | A dense, fast `Int` hash map with a fixed-sized `capacity` of \(n\). Most operations are

src/AtCoder/Extra/IntMap.hs

@@ -47,7 +47,7 @@ module AtCoder.Extra.IntMap
     member,
     notMember,
 
-    -- ** Compartive lookups
+    -- ** Comparative lookups
     lookupGE,
     lookupGT,
     lookupLE,

src/AtCoder/Extra/IntSet.hs

@@ -48,7 +48,7 @@ module AtCoder.Extra.IntSet
     member,
     notMember,
 
-    -- ** Compartive lookups
+    -- ** Comparative lookups
     lookupGE,
     lookupGT,
     lookupLE,