@@ -23,12 +23,7 @@ newtype Loc a = Loc { node :: Tree a
2323 , parents :: List (Loc a)
2424 }
2525
26−instance eqLoc :: Eq a => Eq (Loc a) where
27− eq (Loc r1) (Loc r2) =
28− r1.node == r2.node
29− && r1.before == r2.before
30− && r1.after == r2.after
31− && r1.parents == r2.parents
26+derive newtype instance eqLoc :: Eq a => Eq (Loc a)
3227
3328-- -- Cursor movement
3429
@@ -37,32 +32,29 @@ next :: forall a. Loc a -> Maybe (Loc a)
3732next (Loc r) =
3833 case r.after of
3934 Nil -> Nothing
40− (c:cs) -> Just $ Loc { node: c
41− , before: r.node : r.before
42− , after: cs
43− , parents: r.parents
44− }
35+ (c:cs) -> Just $ Loc r { node = c
36+ , before = r.node : r.before
37+ , after = cs
38+ }
4539
4640-- -- | Move the cursor to the previous sibling.
4741prev :: forall a. Loc a -> Maybe (Loc a)
4842prev (Loc r) =
4943 case r.before of
5044 Nil -> Nothing
51− (c:cs) -> Just $ Loc { node: c
52− , before: cs
53− , after: r.node : r.after
54− , parents: r.parents
55− }
45+ (c:cs) -> Just $ Loc r { node = c
46+ , before = cs
47+ , after = r.node : r.after
48+ }
5649
5750-- -- | Move the cursor to the first sibling.
5851first :: forall a. Loc a -> Loc a
5952first l@(Loc r) =
6053 case r.before of
6154 Nil -> l
62− c:cs -> Loc $ { node: c
63− , before: Nil
64− , after: (reverse cs) <> r.after
65− , parents: r.parents
55+ c:cs -> Loc r { node = c
56+ , before = Nil
57+ , after = (reverse cs) <> r.after
6658 }
6759
6860-- -- | Move the cursor to the last sibling.
@@ -70,10 +62,9 @@ last :: forall a. Loc a -> Loc a
7062last l@(Loc r) =
7163 case reverse r.after of
7264 Nil -> l
73− c:cs -> Loc $ { node: c
74− , before: cs <> (r.node : r.before)
75− , after: Nil
76− , parents: r.parents
65+ c:cs -> Loc r { node = c
66+ , before = cs <> (r.node : r.before)
67+ , after = Nil
7768 }
7869
7970-- -- | Move the cursor to the parent `Node`.
@@ -116,20 +107,16 @@ lastChild p@(Loc r) = last <$> down p
116107
117108-- | Move the cursor to a specific sibling by it's index.
118109siblingAt :: forall a. Int -> Loc a -> Maybe (Loc a)
119−siblingAt i l@(Loc r) =
120− case up l of
121− Nothing -> Nothing
122− Just p@(Loc r') ->
123− case (children p) !! i of
124− Nothing -> Nothing
125− Just c ->
126− let before' = reverse $ take i (children p)
127− after' = drop (i+1) (children p)
128− in Just $ Loc { node: c
129− , before: before'
130− , after: after'
131− , parents: r.parents
132− }
110+siblingAt i l@(Loc r) = do
111+ p@(Loc r') <- up l
112+ c <- (children p) !! i
113+ let before' = reverse $ take i (children p)
114+ let after' = drop (i+1) (children p)
115+ pure $ Loc { node: c
116+ , before: before'
117+ , after: after'
118+ , parents: r.parents
119+ }
133120
134121-- | Move the cursor to a specific child of the current `Node` by it's index.
135122childAt :: forall a. Int -> Loc a -> Maybe (Loc a)
@@ -151,19 +138,11 @@ fromTree n = Loc { node: n
151138
152139-- | Set the `Node` at the current position.
153140setNode :: forall a. Tree a -> Loc a -> Loc a
154−setNode a (Loc r) = Loc { node: a
155− , before: r.before
156− , after: r.after
157− , parents: r.parents
158− }
141+setNode a (Loc r) = Loc r { node = a }
159142
160143-- | Set the `Node` at the current position.
161144modifyNode :: forall a. (Tree a -> Tree a) -> Loc a -> Loc a
162−modifyNode f (Loc r) = Loc { node: f r.node
163− , before: r.before
164− , after: r.after
165− , parents: r.parents
166− }
145+modifyNode f (Loc r) = Loc r { node = f r.node }
167146
168147-- | Set the value of the current `Node`.
169148setValue :: forall a. a -> Loc a -> Loc a