{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}

module Cursor.Tree.Movement
  ( treeCursorSelection,
    TreeCursorSelection (..),
    treeCursorSelect,
    treeCursorSelectPrev,
    treeCursorSelectNext,
    treeCursorSelectFirst,
    treeCursorSelectLast,
    treeCursorSelectAbove,
    treeCursorSelectBelowAtPos,
    treeCursorSelectBelowAtStart,
    treeCursorSelectBelowAtEnd,
    treeCursorSelectBelowAtStartRecursively,
    treeCursorSelectBelowAtEndRecursively,
    treeCursorSelectPrevOnSameLevel,
    treeCursorSelectNextOnSameLevel,
    treeCursorSelectFirstOnSameLevel,
    treeCursorSelectLastOnSameLevel,
    treeCursorSelectAbovePrev,
    treeCursorSelectAboveNext,
  )
where

import Control.Applicative
import Control.Monad
import Cursor.Tree.Base
import Cursor.Tree.Types
import qualified Data.List.NonEmpty as NE
import Data.Validity.Tree ()

treeCursorSelection :: TreeCursor a b -> TreeCursorSelection
treeCursorSelection :: TreeCursor a b -> TreeCursorSelection
treeCursorSelection TreeCursor {a
Maybe (TreeAbove b)
CForest b
treeBelow :: forall a b. TreeCursor a b -> CForest b
treeCurrent :: forall a b. TreeCursor a b -> a
treeAbove :: forall a b. TreeCursor a b -> Maybe (TreeAbove b)
treeBelow :: CForest b
treeCurrent :: a
treeAbove :: Maybe (TreeAbove b)
..} = Maybe (TreeAbove b) -> TreeCursorSelection -> TreeCursorSelection
forall a.
Maybe (TreeAbove a) -> TreeCursorSelection -> TreeCursorSelection
wrap Maybe (TreeAbove b)
treeAbove TreeCursorSelection
SelectNode
  where
    wrap :: Maybe (TreeAbove a) -> TreeCursorSelection -> TreeCursorSelection
    wrap :: Maybe (TreeAbove a) -> TreeCursorSelection -> TreeCursorSelection
wrap Maybe (TreeAbove a)
Nothing TreeCursorSelection
ts = TreeCursorSelection
ts
    wrap (Just TreeAbove a
ta) TreeCursorSelection
ts = Maybe (TreeAbove a) -> TreeCursorSelection -> TreeCursorSelection
forall a.
Maybe (TreeAbove a) -> TreeCursorSelection -> TreeCursorSelection
wrap (TreeAbove a -> Maybe (TreeAbove a)
forall b. TreeAbove b -> Maybe (TreeAbove b)
treeAboveAbove TreeAbove a
ta) (TreeCursorSelection -> TreeCursorSelection)
-> TreeCursorSelection -> TreeCursorSelection
forall a b. (a -> b) -> a -> b
$ Int -> TreeCursorSelection -> TreeCursorSelection
SelectChild ([CTree a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([CTree a] -> Int) -> [CTree a] -> Int
forall a b. (a -> b) -> a -> b
$ TreeAbove a -> [CTree a]
forall b. TreeAbove b -> [CTree b]
treeAboveLefts TreeAbove a
ta) TreeCursorSelection
ts

treeCursorSelect ::
  (a -> b) -> (b -> a) -> TreeCursorSelection -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelect :: (a -> b)
-> (b -> a)
-> TreeCursorSelection
-> TreeCursor a b
-> Maybe (TreeCursor a b)
treeCursorSelect a -> b
f b -> a
g TreeCursorSelection
sel = (a -> b)
-> (b -> a)
-> TreeCursorSelection
-> CTree b
-> Maybe (TreeCursor a b)
forall a b.
(a -> b)
-> (b -> a)
-> TreeCursorSelection
-> CTree b
-> Maybe (TreeCursor a b)
makeTreeCursorWithSelection a -> b
f b -> a
g TreeCursorSelection
sel (CTree b -> Maybe (TreeCursor a b))
-> (TreeCursor a b -> CTree b)
-> TreeCursor a b
-> Maybe (TreeCursor a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> TreeCursor a b -> CTree b
forall a b. (a -> b) -> TreeCursor a b -> CTree b
rebuildTreeCursor a -> b
f

treeCursorSelectPrev :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrev :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrev a -> b
f b -> a
g TreeCursor a b
tc =
  (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbovePrev a -> b
f b -> a
g TreeCursor a b
tc Maybe (TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrevOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc
    Maybe (TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbove a -> b
f b -> a
g TreeCursor a b
tc

treeCursorSelectNext :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNext :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNext a -> b
f b -> a
g TreeCursor a b
tc =
  (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStart a -> b
f b -> a
g TreeCursor a b
tc Maybe (TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc
    Maybe (TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAboveNext a -> b
f b -> a
g TreeCursor a b
tc

treeCursorSelectFirst :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirst :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirst a -> b
f b -> a
g TreeCursor a b
tc = TreeCursor a b
-> (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b)
-> TreeCursor a b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TreeCursor a b
tc ((a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirst a -> b
f b -> a
g) (Maybe (TreeCursor a b) -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> TreeCursor a b
forall a b. (a -> b) -> a -> b
$ (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrev a -> b
f b -> a
g TreeCursor a b
tc

treeCursorSelectLast :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLast :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLast a -> b
f b -> a
g TreeCursor a b
tc = TreeCursor a b
-> (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b)
-> TreeCursor a b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TreeCursor a b
tc ((a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLast a -> b
f b -> a
g) (Maybe (TreeCursor a b) -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> TreeCursor a b
forall a b. (a -> b) -> a -> b
$ (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNext a -> b
f b -> a
g TreeCursor a b
tc

treeCursorSelectAbove :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbove :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbove a -> b
f b -> a
g tc :: TreeCursor a b
tc@TreeCursor {a
Maybe (TreeAbove b)
CForest b
treeBelow :: CForest b
treeCurrent :: a
treeAbove :: Maybe (TreeAbove b)
treeBelow :: forall a b. TreeCursor a b -> CForest b
treeCurrent :: forall a b. TreeCursor a b -> a
treeAbove :: forall a b. TreeCursor a b -> Maybe (TreeAbove b)
..} =
  case Maybe (TreeAbove b)
treeAbove of
    Maybe (TreeAbove b)
Nothing -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    Just TreeAbove {b
[CTree b]
Maybe (TreeAbove b)
treeAboveRights :: forall b. TreeAbove b -> [CTree b]
treeAboveNode :: forall b. TreeAbove b -> b
treeAboveRights :: [CTree b]
treeAboveNode :: b
treeAboveAbove :: Maybe (TreeAbove b)
treeAboveLefts :: [CTree b]
treeAboveLefts :: forall b. TreeAbove b -> [CTree b]
treeAboveAbove :: forall b. TreeAbove b -> Maybe (TreeAbove b)
..} ->
      let newForest :: [CTree b]
newForest = [CTree b] -> [CTree b]
forall a. [a] -> [a]
reverse [CTree b]
treeAboveLefts [CTree b] -> [CTree b] -> [CTree b]
forall a. [a] -> [a] -> [a]
++ [(a -> b) -> TreeCursor a b -> CTree b
forall a b. (a -> b) -> TreeCursor a b -> CTree b
currentTree a -> b
f TreeCursor a b
tc] [CTree b] -> [CTree b] -> [CTree b]
forall a. [a] -> [a] -> [a]
++ [CTree b]
treeAboveRights
          newTree :: CTree b
newTree = b -> CForest b -> CTree b
forall a. a -> CForest a -> CTree a
CNode b
treeAboveNode (CForest b -> CTree b) -> CForest b -> CTree b
forall a b. (a -> b) -> a -> b
$ [CTree b] -> CForest b
forall a. [CTree a] -> CForest a
openForest [CTree b]
newForest
       in TreeCursor a b -> Maybe (TreeCursor a b)
forall a. a -> Maybe a
Just (TreeCursor a b -> Maybe (TreeCursor a b))
-> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b. (a -> b) -> a -> b
$ (b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
forall b a.
(b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
makeTreeCursorWithAbove b -> a
g CTree b
newTree Maybe (TreeAbove b)
treeAboveAbove

treeCursorSelectBelowAtPos ::
  (a -> b) -> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtPos :: (a -> b)
-> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtPos a -> b
f b -> a
g Int
pos TreeCursor {a
Maybe (TreeAbove b)
CForest b
treeBelow :: CForest b
treeCurrent :: a
treeAbove :: Maybe (TreeAbove b)
treeBelow :: forall a b. TreeCursor a b -> CForest b
treeCurrent :: forall a b. TreeCursor a b -> a
treeAbove :: forall a b. TreeCursor a b -> Maybe (TreeAbove b)
..} =
  case CForest b
treeBelow of
    CForest b
EmptyCForest -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    ClosedForest NonEmpty (Tree b)
_ -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    OpenForest NonEmpty (CTree b)
ts ->
      case Int -> [CTree b] -> ([CTree b], [CTree b])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
pos ([CTree b] -> ([CTree b], [CTree b]))
-> [CTree b] -> ([CTree b], [CTree b])
forall a b. (a -> b) -> a -> b
$ NonEmpty (CTree b) -> [CTree b]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (CTree b)
ts of
        ([CTree b]
_, []) -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
        ([CTree b]
lefts, CTree b
current : [CTree b]
rights) ->
          TreeCursor a b -> Maybe (TreeCursor a b)
forall a. a -> Maybe a
Just (TreeCursor a b -> Maybe (TreeCursor a b))
-> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b. (a -> b) -> a -> b
$
            (b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
forall b a.
(b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
makeTreeCursorWithAbove b -> a
g CTree b
current (Maybe (TreeAbove b) -> TreeCursor a b)
-> Maybe (TreeAbove b) -> TreeCursor a b
forall a b. (a -> b) -> a -> b
$
              TreeAbove b -> Maybe (TreeAbove b)
forall a. a -> Maybe a
Just (TreeAbove b -> Maybe (TreeAbove b))
-> TreeAbove b -> Maybe (TreeAbove b)
forall a b. (a -> b) -> a -> b
$
                TreeAbove :: forall b.
[CTree b] -> Maybe (TreeAbove b) -> b -> [CTree b] -> TreeAbove b
TreeAbove
                  { treeAboveLefts :: [CTree b]
treeAboveLefts = [CTree b] -> [CTree b]
forall a. [a] -> [a]
reverse [CTree b]
lefts,
                    treeAboveAbove :: Maybe (TreeAbove b)
treeAboveAbove = Maybe (TreeAbove b)
treeAbove,
                    treeAboveNode :: b
treeAboveNode = a -> b
f a
treeCurrent,
                    treeAboveRights :: [CTree b]
treeAboveRights = [CTree b]
rights
                  }

treeCursorSelectBelowAtStart :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStart :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStart a -> b
f b -> a
g = (a -> b)
-> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b)
-> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtPos a -> b
f b -> a
g Int
0

treeCursorSelectBelowAtEnd :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEnd :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEnd a -> b
f b -> a
g TreeCursor a b
tc =
  case TreeCursor a b -> CForest b
forall a b. TreeCursor a b -> CForest b
treeBelow TreeCursor a b
tc of
    CForest b
EmptyCForest -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    ClosedForest NonEmpty (Tree b)
_ -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    OpenForest NonEmpty (CTree b)
ts -> (a -> b)
-> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b)
-> (b -> a) -> Int -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtPos a -> b
f b -> a
g (NonEmpty (CTree b) -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length NonEmpty (CTree b)
ts Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) TreeCursor a b
tc

treeCursorSelectBelowAtStartRecursively ::
  (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStartRecursively :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStartRecursively a -> b
f b -> a
g TreeCursor a b
tc = TreeCursor a b -> TreeCursor a b
go (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStart a -> b
f b -> a
g TreeCursor a b
tc
  where
    go :: TreeCursor a b -> TreeCursor a b
go TreeCursor a b
c = TreeCursor a b
-> (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b)
-> TreeCursor a b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TreeCursor a b
c TreeCursor a b -> TreeCursor a b
go (Maybe (TreeCursor a b) -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> TreeCursor a b
forall a b. (a -> b) -> a -> b
$ (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtStart a -> b
f b -> a
g TreeCursor a b
c

treeCursorSelectBelowAtEndRecursively ::
  (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEndRecursively :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEndRecursively a -> b
f b -> a
g TreeCursor a b
tc = TreeCursor a b -> TreeCursor a b
go (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> Maybe (TreeCursor a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEnd a -> b
f b -> a
g TreeCursor a b
tc
  where
    go :: TreeCursor a b -> TreeCursor a b
go TreeCursor a b
c = TreeCursor a b
-> (TreeCursor a b -> TreeCursor a b)
-> Maybe (TreeCursor a b)
-> TreeCursor a b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TreeCursor a b
c TreeCursor a b -> TreeCursor a b
go (Maybe (TreeCursor a b) -> TreeCursor a b)
-> Maybe (TreeCursor a b) -> TreeCursor a b
forall a b. (a -> b) -> a -> b
$ (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEnd a -> b
f b -> a
g TreeCursor a b
c

treeCursorSelectPrevOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrevOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrevOnSameLevel a -> b
f b -> a
g tc :: TreeCursor a b
tc@TreeCursor {a
Maybe (TreeAbove b)
CForest b
treeBelow :: CForest b
treeCurrent :: a
treeAbove :: Maybe (TreeAbove b)
treeBelow :: forall a b. TreeCursor a b -> CForest b
treeCurrent :: forall a b. TreeCursor a b -> a
treeAbove :: forall a b. TreeCursor a b -> Maybe (TreeAbove b)
..} = do
  TreeAbove b
ta <- Maybe (TreeAbove b)
treeAbove
  case TreeAbove b -> [CTree b]
forall b. TreeAbove b -> [CTree b]
treeAboveLefts TreeAbove b
ta of
    [] -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    CTree b
tree : [CTree b]
xs ->
      TreeCursor a b -> Maybe (TreeCursor a b)
forall a. a -> Maybe a
Just (TreeCursor a b -> Maybe (TreeCursor a b))
-> (Maybe (TreeAbove b) -> TreeCursor a b)
-> Maybe (TreeAbove b)
-> Maybe (TreeCursor a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
forall b a.
(b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
makeTreeCursorWithAbove b -> a
g CTree b
tree (Maybe (TreeAbove b) -> Maybe (TreeCursor a b))
-> Maybe (TreeAbove b) -> Maybe (TreeCursor a b)
forall a b. (a -> b) -> a -> b
$
        TreeAbove b -> Maybe (TreeAbove b)
forall a. a -> Maybe a
Just TreeAbove b
ta {treeAboveLefts :: [CTree b]
treeAboveLefts = [CTree b]
xs, treeAboveRights :: [CTree b]
treeAboveRights = (a -> b) -> TreeCursor a b -> CTree b
forall a b. (a -> b) -> TreeCursor a b -> CTree b
currentTree a -> b
f TreeCursor a b
tc CTree b -> [CTree b] -> [CTree b]
forall a. a -> [a] -> [a]
: TreeAbove b -> [CTree b]
forall b. TreeAbove b -> [CTree b]
treeAboveRights TreeAbove b
ta}

treeCursorSelectNextOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel a -> b
f b -> a
g tc :: TreeCursor a b
tc@TreeCursor {a
Maybe (TreeAbove b)
CForest b
treeBelow :: CForest b
treeCurrent :: a
treeAbove :: Maybe (TreeAbove b)
treeBelow :: forall a b. TreeCursor a b -> CForest b
treeCurrent :: forall a b. TreeCursor a b -> a
treeAbove :: forall a b. TreeCursor a b -> Maybe (TreeAbove b)
..} = do
  TreeAbove b
ta <- Maybe (TreeAbove b)
treeAbove
  case TreeAbove b -> [CTree b]
forall b. TreeAbove b -> [CTree b]
treeAboveRights TreeAbove b
ta of
    [] -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    CTree b
tree : [CTree b]
xs ->
      TreeCursor a b -> Maybe (TreeCursor a b)
forall a. a -> Maybe a
Just (TreeCursor a b -> Maybe (TreeCursor a b))
-> (TreeAbove b -> TreeCursor a b)
-> TreeAbove b
-> Maybe (TreeCursor a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
forall b a.
(b -> a) -> CTree b -> Maybe (TreeAbove b) -> TreeCursor a b
makeTreeCursorWithAbove b -> a
g CTree b
tree (Maybe (TreeAbove b) -> TreeCursor a b)
-> (TreeAbove b -> Maybe (TreeAbove b))
-> TreeAbove b
-> TreeCursor a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TreeAbove b -> Maybe (TreeAbove b)
forall a. a -> Maybe a
Just (TreeAbove b -> Maybe (TreeCursor a b))
-> TreeAbove b -> Maybe (TreeCursor a b)
forall a b. (a -> b) -> a -> b
$
        TreeAbove b
ta {treeAboveLefts :: [CTree b]
treeAboveLefts = (a -> b) -> TreeCursor a b -> CTree b
forall a b. (a -> b) -> TreeCursor a b -> CTree b
currentTree a -> b
f TreeCursor a b
tc CTree b -> [CTree b] -> [CTree b]
forall a. a -> [a] -> [a]
: TreeAbove b -> [CTree b]
forall b. TreeAbove b -> [CTree b]
treeAboveLefts TreeAbove b
ta, treeAboveRights :: [CTree b]
treeAboveRights = [CTree b]
xs}

treeCursorSelectFirstOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirstOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirstOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc =
  case (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrevOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc of
    Maybe (TreeCursor a b)
Nothing -> TreeCursor a b
tc
    Just TreeCursor a b
tc' -> (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectFirstOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc'

treeCursorSelectLastOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLastOnSameLevel :: (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLastOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc =
  case (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc of
    Maybe (TreeCursor a b)
Nothing -> TreeCursor a b
tc
    Just TreeCursor a b
tc' -> (a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> TreeCursor a b
treeCursorSelectLastOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc'

-- | Go back and down as far as necessary to find a previous element on a level below
treeCursorSelectAbovePrev :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbovePrev :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbovePrev a -> b
f b -> a
g =
  (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectPrevOnSameLevel a -> b
f b -> a
g (TreeCursor a b -> Maybe (TreeCursor a b))
-> (TreeCursor a b -> Maybe (TreeCursor a b))
-> TreeCursor a b
-> Maybe (TreeCursor a b)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectBelowAtEndRecursively a -> b
f b -> a
g

-- | Go up as far as necessary to find a next element on a level above and forward
--
-- Note: This will fail if there is a next node on the same level or any node below the current node
treeCursorSelectAboveNext :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAboveNext :: (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAboveNext a -> b
f b -> a
g TreeCursor a b
tc =
  case (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc of
    Just TreeCursor a b
_ -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
    Maybe (TreeCursor a b)
Nothing ->
      case TreeCursor a b -> CForest b
forall a b. TreeCursor a b -> CForest b
treeBelow TreeCursor a b
tc of
        CForest b
EmptyCForest -> TreeCursor a b -> Maybe (TreeCursor a b)
go TreeCursor a b
tc
        ClosedForest NonEmpty (Tree b)
_ -> TreeCursor a b -> Maybe (TreeCursor a b)
go TreeCursor a b
tc
        OpenForest NonEmpty (CTree b)
_ -> Maybe (TreeCursor a b)
forall a. Maybe a
Nothing
  where
    go :: TreeCursor a b -> Maybe (TreeCursor a b)
go TreeCursor a b
tc_ = do
      TreeCursor a b
tc' <- (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectAbove a -> b
f b -> a
g TreeCursor a b
tc_
      case (a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
forall a b.
(a -> b) -> (b -> a) -> TreeCursor a b -> Maybe (TreeCursor a b)
treeCursorSelectNextOnSameLevel a -> b
f b -> a
g TreeCursor a b
tc' of
        Maybe (TreeCursor a b)
Nothing -> TreeCursor a b -> Maybe (TreeCursor a b)
go TreeCursor a b
tc'
        Just TreeCursor a b
tc'' -> TreeCursor a b -> Maybe (TreeCursor a b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure TreeCursor a b
tc''