module Text.XmlHtml.Cursor (
Cursor,
fromNode,
fromNodes,
topNode,
topNodes,
current,
siblings,
parent,
root,
getChild,
firstChild,
lastChild,
left,
right,
nextDF,
findChild,
findLeft,
findRight,
findRec,
isRoot,
isFirst,
isLast,
isLeaf,
isChild,
hasChildren,
getNodeIndex,
setNode,
modifyNode,
modifyNodeM,
insertLeft,
insertRight,
insertManyLeft,
insertManyRight,
insertFirstChild,
insertLastChild,
insertManyFirstChild,
insertManyLastChild,
insertGoLeft,
insertGoRight,
removeLeft,
removeRight,
removeGoLeft,
removeGoRight,
removeGoUp
) where
import Control.Monad
import Data.Maybe
import Data.Text (Text)
import Text.XmlHtml
type Tag = (Text, [(Text, Text)])
fromTag :: Tag -> [Node] -> Node
fromTag :: Tag -> [Node] -> Node
fromTag (t :: Text
t,a :: [(Text, Text)]
a) c :: [Node]
c = Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a [Node]
c
data Cursor = Cursor {
Cursor -> Node
current :: !Node,
Cursor -> [Node]
lefts :: ![Node],
Cursor -> [Node]
rights :: ![Node],
Cursor -> [([Node], Tag, [Node])]
parents :: ![([Node], Tag, [Node])]
}
deriving (Cursor -> Cursor -> Bool
(Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Bool) -> Eq Cursor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cursor -> Cursor -> Bool
$c/= :: Cursor -> Cursor -> Bool
== :: Cursor -> Cursor -> Bool
$c== :: Cursor -> Cursor -> Bool
Eq)
fromNode :: Node -> Cursor
fromNode :: Node -> Cursor
fromNode n :: Node
n = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n [] [] []
fromNodes :: [Node] -> Maybe Cursor
fromNodes :: [Node] -> Maybe Cursor
fromNodes (n :: Node
n:ns :: [Node]
ns) = Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n [] [Node]
ns [])
fromNodes [] = Maybe Cursor
forall a. Maybe a
Nothing
topNode :: Cursor -> Node
topNode :: Cursor -> Node
topNode cur :: Cursor
cur = Cursor -> Node
current (Cursor -> Cursor
root Cursor
cur)
topNodes :: Cursor -> [Node]
topNodes :: Cursor -> [Node]
topNodes cur :: Cursor
cur = Cursor -> [Node]
siblings (Cursor -> Cursor
root Cursor
cur)
siblings :: Cursor -> [Node]
siblings :: Cursor -> [Node]
siblings (Cursor cur :: Node
cur ls :: [Node]
ls rs :: [Node]
rs _) = ([Node] -> Node -> [Node]) -> [Node] -> [Node] -> [Node]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((Node -> [Node] -> [Node]) -> [Node] -> Node -> [Node]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (:)) (Node
curNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
rs) [Node]
ls
parent :: Cursor -> Maybe Cursor
parent :: Cursor -> Maybe Cursor
parent c :: Cursor
c@(Cursor _ _ _ ((ls :: [Node]
ls,t :: Tag
t,rs :: [Node]
rs):ps :: [([Node], Tag, [Node])]
ps))
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Tag -> [Node] -> Node
fromTag Tag
t (Cursor -> [Node]
siblings Cursor
c)) [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
parent _ = Maybe Cursor
forall a. Maybe a
Nothing
root :: Cursor -> Cursor
root :: Cursor -> Cursor
root = (Cursor -> Bool) -> (Cursor -> Cursor) -> Cursor -> Cursor
forall a. (a -> Bool) -> (a -> a) -> a -> a
until Cursor -> Bool
isRoot (Maybe Cursor -> Cursor
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Cursor -> Cursor)
-> (Cursor -> Maybe Cursor) -> Cursor -> Cursor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> Maybe Cursor
parent)
getChild :: Int -> Cursor -> Maybe Cursor
getChild :: Int -> Cursor -> Maybe Cursor
getChild i :: Int
i (Cursor n :: Node
n ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) =
case Node
n of
Element t :: Text
t a :: [(Text, Text)]
a cs :: [Node]
cs -> let (lls :: [Node]
lls, rest :: [Node]
rest) = Int -> [Node] -> ([Node], [Node])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
i [Node]
cs in
if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= [Node] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Node]
cs Bool -> Bool -> Bool
|| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0
then Maybe Cursor
forall a. Maybe a
Nothing
else Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
forall a b. (a -> b) -> a -> b
$ Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor ([Node] -> Node
forall a. [a] -> a
head [Node]
rest)
([Node] -> [Node]
forall a. [a] -> [a]
reverse [Node]
lls)
([Node] -> [Node]
forall a. [a] -> [a]
tail [Node]
rest)
(([Node]
ls, (Text
t,[(Text, Text)]
a), [Node]
rs)([Node], Tag, [Node])
-> [([Node], Tag, [Node])] -> [([Node], Tag, [Node])]
forall a. a -> [a] -> [a]
:[([Node], Tag, [Node])]
ps)
_ -> Maybe Cursor
forall a. Maybe a
Nothing
firstChild :: Cursor -> Maybe Cursor
firstChild :: Cursor -> Maybe Cursor
firstChild = Int -> Cursor -> Maybe Cursor
getChild 0
lastChild :: Cursor -> Maybe Cursor
lastChild :: Cursor -> Maybe Cursor
lastChild (Cursor (Element t :: Text
t a :: [(Text, Text)]
a c :: [Node]
c) ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) | Bool -> Bool
not ([Node] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Node]
c)
= let rc :: [Node]
rc = [Node] -> [Node]
forall a. [a] -> [a]
reverse [Node]
c
in Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
forall a b. (a -> b) -> a -> b
$ Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor ([Node] -> Node
forall a. [a] -> a
head [Node]
rc) ([Node] -> [Node]
forall a. [a] -> [a]
tail [Node]
rc) [] (([Node]
ls, (Text
t,[(Text, Text)]
a), [Node]
rs)([Node], Tag, [Node])
-> [([Node], Tag, [Node])] -> [([Node], Tag, [Node])]
forall a. a -> [a] -> [a]
:[([Node], Tag, [Node])]
ps)
lastChild _
= Maybe Cursor
forall a. Maybe a
Nothing
left :: Cursor -> Maybe Cursor
left :: Cursor -> Maybe Cursor
left (Cursor c :: Node
c (l :: Node
l:ls :: [Node]
ls) rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
l [Node]
ls (Node
cNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
rs) [([Node], Tag, [Node])]
ps)
left _ = Maybe Cursor
forall a. Maybe a
Nothing
right :: Cursor -> Maybe Cursor
right :: Cursor -> Maybe Cursor
right (Cursor c :: Node
c ls :: [Node]
ls (r :: Node
r:rs :: [Node]
rs) ps :: [([Node], Tag, [Node])]
ps) = Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
r (Node
cNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
ls) [Node]
rs [([Node], Tag, [Node])]
ps)
right _ = Maybe Cursor
forall a. Maybe a
Nothing
nextDF :: Cursor -> Maybe Cursor
nextDF :: Cursor -> Maybe Cursor
nextDF c :: Cursor
c = Cursor -> Maybe Cursor
firstChild Cursor
c Maybe Cursor -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Cursor -> Maybe Cursor
up Cursor
c
where up :: Cursor -> Maybe Cursor
up x :: Cursor
x = Cursor -> Maybe Cursor
right Cursor
x Maybe Cursor -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` (Cursor -> Maybe Cursor
up (Cursor -> Maybe Cursor) -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Cursor -> Maybe Cursor
parent Cursor
x)
search :: (Cursor -> Bool)
-> (Cursor -> Maybe Cursor)
-> Cursor
-> Maybe Cursor
search :: (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search p :: Cursor -> Bool
p move :: Cursor -> Maybe Cursor
move c :: Cursor
c | Cursor -> Bool
p Cursor
c = Cursor -> Maybe Cursor
forall (m :: * -> *) a. Monad m => a -> m a
return Cursor
c
| Bool
otherwise = (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search Cursor -> Bool
p Cursor -> Maybe Cursor
move (Cursor -> Maybe Cursor) -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Cursor -> Maybe Cursor
move Cursor
c
findChild :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findChild :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findChild p :: Cursor -> Bool
p cur :: Cursor
cur = (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search Cursor -> Bool
p Cursor -> Maybe Cursor
right (Cursor -> Maybe Cursor) -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Cursor -> Maybe Cursor
firstChild Cursor
cur
findLeft :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findLeft :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findLeft p :: Cursor -> Bool
p cur :: Cursor
cur = (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search Cursor -> Bool
p Cursor -> Maybe Cursor
left (Cursor -> Maybe Cursor) -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Cursor -> Maybe Cursor
left Cursor
cur
findRight :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findRight :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findRight p :: Cursor -> Bool
p cur :: Cursor
cur = (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search Cursor -> Bool
p Cursor -> Maybe Cursor
right (Cursor -> Maybe Cursor) -> Maybe Cursor -> Maybe Cursor
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Cursor -> Maybe Cursor
right Cursor
cur
findRec :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findRec :: (Cursor -> Bool) -> Cursor -> Maybe Cursor
findRec p :: Cursor -> Bool
p = (Cursor -> Bool)
-> (Cursor -> Maybe Cursor) -> Cursor -> Maybe Cursor
search Cursor -> Bool
p Cursor -> Maybe Cursor
nextDF
isRoot :: Cursor -> Bool
isRoot :: Cursor -> Bool
isRoot cur :: Cursor
cur = [([Node], Tag, [Node])] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Cursor -> [([Node], Tag, [Node])]
parents Cursor
cur)
isFirst :: Cursor -> Bool
isFirst :: Cursor -> Bool
isFirst cur :: Cursor
cur = [Node] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Cursor -> [Node]
lefts Cursor
cur)
isLast :: Cursor -> Bool
isLast :: Cursor -> Bool
isLast cur :: Cursor
cur = [Node] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Cursor -> [Node]
rights Cursor
cur)
isLeaf :: Cursor -> Bool
isLeaf :: Cursor -> Bool
isLeaf (Cursor (Element _ _ c :: [Node]
c) _ _ _) = [Node] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Node]
c
isLeaf _ = Bool
True
isChild :: Cursor -> Bool
isChild :: Cursor -> Bool
isChild = Bool -> Bool
not (Bool -> Bool) -> (Cursor -> Bool) -> Cursor -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> Bool
isRoot
hasChildren :: Cursor -> Bool
hasChildren :: Cursor -> Bool
hasChildren = Bool -> Bool
not (Bool -> Bool) -> (Cursor -> Bool) -> Cursor -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> Bool
isLeaf
getNodeIndex :: Cursor -> Int
getNodeIndex :: Cursor -> Int
getNodeIndex cur :: Cursor
cur = [Node] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Cursor -> [Node]
lefts Cursor
cur)
setNode :: Node -> Cursor -> Cursor
setNode :: Node -> Cursor -> Cursor
setNode n :: Node
n cur :: Cursor
cur = Cursor
cur { current :: Node
current = Node
n }
modifyNode :: (Node -> Node) -> Cursor -> Cursor
modifyNode :: (Node -> Node) -> Cursor -> Cursor
modifyNode f :: Node -> Node
f cur :: Cursor
cur = Node -> Cursor -> Cursor
setNode (Node -> Node
f (Cursor -> Node
current Cursor
cur)) Cursor
cur
modifyNodeM :: Functor m => (Node -> m Node) -> Cursor -> m Cursor
modifyNodeM :: (Node -> m Node) -> Cursor -> m Cursor
modifyNodeM f :: Node -> m Node
f cur :: Cursor
cur = (Node -> Cursor -> Cursor) -> Cursor -> Node -> Cursor
forall a b c. (a -> b -> c) -> b -> a -> c
flip Node -> Cursor -> Cursor
setNode Cursor
cur (Node -> Cursor) -> m Node -> m Cursor
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Node -> m Node
f (Cursor -> Node
current Cursor
cur)
insertLeft :: Node -> Cursor -> Cursor
insertLeft :: Node -> Cursor -> Cursor
insertLeft n :: Node
n (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
nn (Node
nNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
ls) [Node]
rs [([Node], Tag, [Node])]
ps
insertRight :: Node -> Cursor -> Cursor
insertRight :: Node -> Cursor -> Cursor
insertRight n :: Node
n (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
nn [Node]
ls (Node
nNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
rs) [([Node], Tag, [Node])]
ps
insertManyLeft :: [Node] -> Cursor -> Cursor
insertManyLeft :: [Node] -> Cursor -> Cursor
insertManyLeft ns :: [Node]
ns (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
nn ([Node] -> [Node]
forall a. [a] -> [a]
reverse [Node]
ns [Node] -> [Node] -> [Node]
forall a. [a] -> [a] -> [a]
++ [Node]
ls) [Node]
rs [([Node], Tag, [Node])]
ps
insertManyRight :: [Node] -> Cursor -> Cursor
insertManyRight :: [Node] -> Cursor -> Cursor
insertManyRight ns :: [Node]
ns (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
nn [Node]
ls ([Node]
ns [Node] -> [Node] -> [Node]
forall a. [a] -> [a] -> [a]
++ [Node]
rs) [([Node], Tag, [Node])]
ps
insertFirstChild :: Node -> Cursor -> Maybe Cursor
insertFirstChild :: Node -> Cursor -> Maybe Cursor
insertFirstChild n :: Node
n (Cursor (Element t :: Text
t a :: [(Text, Text)]
a c :: [Node]
c) ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps)
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a (Node
nNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
c)) [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
insertFirstChild _ _
= Maybe Cursor
forall a. Maybe a
Nothing
insertLastChild :: Node -> Cursor -> Maybe Cursor
insertLastChild :: Node -> Cursor -> Maybe Cursor
insertLastChild n :: Node
n (Cursor (Element t :: Text
t a :: [(Text, Text)]
a c :: [Node]
c) ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps)
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a ([Node]
c [Node] -> [Node] -> [Node]
forall a. [a] -> [a] -> [a]
++ [Node
n])) [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
insertLastChild _ _
= Maybe Cursor
forall a. Maybe a
Nothing
insertManyFirstChild :: [Node] -> Cursor -> Maybe Cursor
insertManyFirstChild :: [Node] -> Cursor -> Maybe Cursor
insertManyFirstChild ns :: [Node]
ns (Cursor (Element t :: Text
t a :: [(Text, Text)]
a c :: [Node]
c) ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps)
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a ([Node]
ns [Node] -> [Node] -> [Node]
forall a. [a] -> [a] -> [a]
++ [Node]
c)) [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
insertManyFirstChild _ _
= Maybe Cursor
forall a. Maybe a
Nothing
insertManyLastChild :: [Node] -> Cursor -> Maybe Cursor
insertManyLastChild :: [Node] -> Cursor -> Maybe Cursor
insertManyLastChild ns :: [Node]
ns (Cursor (Element t :: Text
t a :: [(Text, Text)]
a c :: [Node]
c) ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps)
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a ([Node]
c [Node] -> [Node] -> [Node]
forall a. [a] -> [a] -> [a]
++ [Node]
ns)) [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
insertManyLastChild _ _
= Maybe Cursor
forall a. Maybe a
Nothing
insertGoLeft :: Node -> Cursor -> Cursor
insertGoLeft :: Node -> Cursor -> Cursor
insertGoLeft n :: Node
n (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n [Node]
ls (Node
nnNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
rs) [([Node], Tag, [Node])]
ps
insertGoRight :: Node -> Cursor -> Cursor
insertGoRight :: Node -> Cursor -> Cursor
insertGoRight n :: Node
n (Cursor nn :: Node
nn ls :: [Node]
ls rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n (Node
nnNode -> [Node] -> [Node]
forall a. a -> [a] -> [a]
:[Node]
ls) [Node]
rs [([Node], Tag, [Node])]
ps
removeLeft :: Cursor -> Maybe (Node, Cursor)
removeLeft :: Cursor -> Maybe (Node, Cursor)
removeLeft (Cursor n :: Node
n (l :: Node
l:ls :: [Node]
ls) rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = (Node, Cursor) -> Maybe (Node, Cursor)
forall a. a -> Maybe a
Just (Node
l, Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
removeLeft _ = Maybe (Node, Cursor)
forall a. Maybe a
Nothing
removeRight :: Cursor -> Maybe (Node, Cursor)
removeRight :: Cursor -> Maybe (Node, Cursor)
removeRight (Cursor n :: Node
n ls :: [Node]
ls (r :: Node
r:rs :: [Node]
rs) ps :: [([Node], Tag, [Node])]
ps) = (Node, Cursor) -> Maybe (Node, Cursor)
forall a. a -> Maybe a
Just (Node
r, Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
n [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
removeRight _ = Maybe (Node, Cursor)
forall a. Maybe a
Nothing
removeGoLeft :: Cursor -> Maybe Cursor
removeGoLeft :: Cursor -> Maybe Cursor
removeGoLeft (Cursor _ (l :: Node
l:ls :: [Node]
ls) rs :: [Node]
rs ps :: [([Node], Tag, [Node])]
ps) = Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
l [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
removeGoLeft _ = Maybe Cursor
forall a. Maybe a
Nothing
removeGoRight :: Cursor -> Maybe Cursor
removeGoRight :: Cursor -> Maybe Cursor
removeGoRight (Cursor _ ls :: [Node]
ls (r :: Node
r:rs :: [Node]
rs) ps :: [([Node], Tag, [Node])]
ps) = Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor Node
r [Node]
ls [Node]
rs [([Node], Tag, [Node])]
ps)
removeGoRight _ = Maybe Cursor
forall a. Maybe a
Nothing
removeGoUp :: Cursor -> Maybe Cursor
removeGoUp :: Cursor -> Maybe Cursor
removeGoUp (Cursor _ ls :: [Node]
ls rs :: [Node]
rs ((lls :: [Node]
lls, (t :: Text
t,a :: [(Text, Text)]
a), rrs :: [Node]
rrs):ps :: [([Node], Tag, [Node])]
ps))
= Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Node -> [Node] -> [Node] -> [([Node], Tag, [Node])] -> Cursor
Cursor (Text -> [(Text, Text)] -> [Node] -> Node
Element Text
t [(Text, Text)]
a [Node]
children) [Node]
lls [Node]
rrs [([Node], Tag, [Node])]
ps)
where
children :: [Node]
children = ([Node] -> Node -> [Node]) -> [Node] -> [Node] -> [Node]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((Node -> [Node] -> [Node]) -> [Node] -> Node -> [Node]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (:)) ([Node]
rs) [Node]
ls
removeGoUp _ = Maybe Cursor
forall a. Maybe a
Nothing