{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving,
             MultiParamTypeClasses, ScopedTypeVariables, TypeFamilies, TypeOperators, UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-simplifiable-class-constraints #-}

-- | This module exports functions for reserializing the parsed tree from the tokens stored with every node.

module Language.Haskell.Reserializer (ParsedLexemes(..), Lexeme(..), TokenType(..), Wrapped,
                                      adjustPositions, lexemes, reserialize, reserializeNested,
                                      sourceLength, joinWrapped, mergeLexemes, mapWrapping, mapWrappings,
                                      PositionAdjustment (PositionAdjustment),
                                      NestedPositionAdjustment (NestedPositionAdjustment), Serialization) where

import Control.Monad.Trans.State.Strict (State, StateT(..), evalState, state)
import Data.Bifunctor (first)
import Data.Data (Data)
import Data.Foldable (find)
import Data.Functor.Compose (Compose(..))
import Data.Functor.Const (Const(..))
import Data.Kind (Type)
import Data.Monoid (Sum(Sum, getSum))
import Data.Semigroup.Factorial (Factorial)
import qualified Data.Semigroup.Factorial as Factorial
import Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import Text.Parser.Input.Position (Position(distance, move))

import qualified Rank2
import qualified Transformation
import qualified Transformation.Rank2
import qualified Transformation.Deep as Deep
import qualified Transformation.Full as Full

type Parsed s = Wrapped Int s

type Wrapped pos s = (,) (pos, ParsedLexemes s, pos)

newtype ParsedLexemes s = Trailing [Lexeme s]
                          deriving (Typeable (ParsedLexemes s)
Typeable (ParsedLexemes s) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ParsedLexemes s -> c (ParsedLexemes s))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ParsedLexemes s))
-> (ParsedLexemes s -> Constr)
-> (ParsedLexemes s -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ParsedLexemes s)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ParsedLexemes s)))
-> ((forall b. Data b => b -> b)
    -> ParsedLexemes s -> ParsedLexemes s)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ParsedLexemes s -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ParsedLexemes s -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ParsedLexemes s -> m (ParsedLexemes s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ParsedLexemes s -> m (ParsedLexemes s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ParsedLexemes s -> m (ParsedLexemes s))
-> Data (ParsedLexemes s)
ParsedLexemes s -> Constr
ParsedLexemes s -> DataType
(forall b. Data b => b -> b) -> ParsedLexemes s -> ParsedLexemes s
forall s. Data s => Typeable (ParsedLexemes s)
forall s. Data s => ParsedLexemes s -> Constr
forall s. Data s => ParsedLexemes s -> DataType
forall s.
Data s =>
(forall b. Data b => b -> b) -> ParsedLexemes s -> ParsedLexemes s
forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> ParsedLexemes s -> u
forall s u.
Data s =>
(forall d. Data d => d -> u) -> ParsedLexemes s -> [u]
forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParsedLexemes s)
forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParsedLexemes s -> c (ParsedLexemes s)
forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParsedLexemes s))
forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParsedLexemes s))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ParsedLexemes s -> u
forall u. (forall d. Data d => d -> u) -> ParsedLexemes s -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParsedLexemes s)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParsedLexemes s -> c (ParsedLexemes s)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParsedLexemes s))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParsedLexemes s))
$cgfoldl :: forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParsedLexemes s -> c (ParsedLexemes s)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParsedLexemes s -> c (ParsedLexemes s)
$cgunfold :: forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParsedLexemes s)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParsedLexemes s)
$ctoConstr :: forall s. Data s => ParsedLexemes s -> Constr
toConstr :: ParsedLexemes s -> Constr
$cdataTypeOf :: forall s. Data s => ParsedLexemes s -> DataType
dataTypeOf :: ParsedLexemes s -> DataType
$cdataCast1 :: forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParsedLexemes s))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParsedLexemes s))
$cdataCast2 :: forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParsedLexemes s))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParsedLexemes s))
$cgmapT :: forall s.
Data s =>
(forall b. Data b => b -> b) -> ParsedLexemes s -> ParsedLexemes s
gmapT :: (forall b. Data b => b -> b) -> ParsedLexemes s -> ParsedLexemes s
$cgmapQl :: forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
$cgmapQr :: forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParsedLexemes s -> r
$cgmapQ :: forall s u.
Data s =>
(forall d. Data d => d -> u) -> ParsedLexemes s -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ParsedLexemes s -> [u]
$cgmapQi :: forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> ParsedLexemes s -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ParsedLexemes s -> u
$cgmapM :: forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
$cgmapMp :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
$cgmapMo :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ParsedLexemes s -> m (ParsedLexemes s)
Data, ParsedLexemes s -> ParsedLexemes s -> Bool
(ParsedLexemes s -> ParsedLexemes s -> Bool)
-> (ParsedLexemes s -> ParsedLexemes s -> Bool)
-> Eq (ParsedLexemes s)
forall s. Eq s => ParsedLexemes s -> ParsedLexemes s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall s. Eq s => ParsedLexemes s -> ParsedLexemes s -> Bool
== :: ParsedLexemes s -> ParsedLexemes s -> Bool
$c/= :: forall s. Eq s => ParsedLexemes s -> ParsedLexemes s -> Bool
/= :: ParsedLexemes s -> ParsedLexemes s -> Bool
Eq, (forall a b. (a -> b) -> ParsedLexemes a -> ParsedLexemes b)
-> (forall a b. a -> ParsedLexemes b -> ParsedLexemes a)
-> Functor ParsedLexemes
forall a b. a -> ParsedLexemes b -> ParsedLexemes a
forall a b. (a -> b) -> ParsedLexemes a -> ParsedLexemes b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ParsedLexemes a -> ParsedLexemes b
fmap :: forall a b. (a -> b) -> ParsedLexemes a -> ParsedLexemes b
$c<$ :: forall a b. a -> ParsedLexemes b -> ParsedLexemes a
<$ :: forall a b. a -> ParsedLexemes b -> ParsedLexemes a
Functor, Int -> ParsedLexemes s -> ShowS
[ParsedLexemes s] -> ShowS
ParsedLexemes s -> String
(Int -> ParsedLexemes s -> ShowS)
-> (ParsedLexemes s -> String)
-> ([ParsedLexemes s] -> ShowS)
-> Show (ParsedLexemes s)
forall s. Show s => Int -> ParsedLexemes s -> ShowS
forall s. Show s => [ParsedLexemes s] -> ShowS
forall s. Show s => ParsedLexemes s -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall s. Show s => Int -> ParsedLexemes s -> ShowS
showsPrec :: Int -> ParsedLexemes s -> ShowS
$cshow :: forall s. Show s => ParsedLexemes s -> String
show :: ParsedLexemes s -> String
$cshowList :: forall s. Show s => [ParsedLexemes s] -> ShowS
showList :: [ParsedLexemes s] -> ShowS
Show, NonEmpty (ParsedLexemes s) -> ParsedLexemes s
ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
(ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s)
-> (NonEmpty (ParsedLexemes s) -> ParsedLexemes s)
-> (forall b.
    Integral b =>
    b -> ParsedLexemes s -> ParsedLexemes s)
-> Semigroup (ParsedLexemes s)
forall b. Integral b => b -> ParsedLexemes s -> ParsedLexemes s
forall s. NonEmpty (ParsedLexemes s) -> ParsedLexemes s
forall s. ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall s b. Integral b => b -> ParsedLexemes s -> ParsedLexemes s
$c<> :: forall s. ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
<> :: ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
$csconcat :: forall s. NonEmpty (ParsedLexemes s) -> ParsedLexemes s
sconcat :: NonEmpty (ParsedLexemes s) -> ParsedLexemes s
$cstimes :: forall s b. Integral b => b -> ParsedLexemes s -> ParsedLexemes s
stimes :: forall b. Integral b => b -> ParsedLexemes s -> ParsedLexemes s
Semigroup, Semigroup (ParsedLexemes s)
ParsedLexemes s
Semigroup (ParsedLexemes s) =>
ParsedLexemes s
-> (ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s)
-> ([ParsedLexemes s] -> ParsedLexemes s)
-> Monoid (ParsedLexemes s)
[ParsedLexemes s] -> ParsedLexemes s
ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall s. Semigroup (ParsedLexemes s)
forall s. ParsedLexemes s
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall s. [ParsedLexemes s] -> ParsedLexemes s
forall s. ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
$cmempty :: forall s. ParsedLexemes s
mempty :: ParsedLexemes s
$cmappend :: forall s. ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
mappend :: ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
$cmconcat :: forall s. [ParsedLexemes s] -> ParsedLexemes s
mconcat :: [ParsedLexemes s] -> ParsedLexemes s
Monoid)

data Lexeme s = WhiteSpace{forall s. Lexeme s -> s
lexemeText :: s}
              | Comment{lexemeText :: s}
              | Token{forall s. Lexeme s -> TokenType
lexemeType :: TokenType,
                      lexemeText :: s}
                deriving (Typeable (Lexeme s)
Typeable (Lexeme s) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Lexeme s -> c (Lexeme s))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Lexeme s))
-> (Lexeme s -> Constr)
-> (Lexeme s -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Lexeme s)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Lexeme s)))
-> ((forall b. Data b => b -> b) -> Lexeme s -> Lexeme s)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Lexeme s -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Lexeme s -> r)
-> (forall u. (forall d. Data d => d -> u) -> Lexeme s -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Lexeme s -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s))
-> Data (Lexeme s)
Lexeme s -> Constr
Lexeme s -> DataType
(forall b. Data b => b -> b) -> Lexeme s -> Lexeme s
forall s. Data s => Typeable (Lexeme s)
forall s. Data s => Lexeme s -> Constr
forall s. Data s => Lexeme s -> DataType
forall s.
Data s =>
(forall b. Data b => b -> b) -> Lexeme s -> Lexeme s
forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> Lexeme s -> u
forall s u.
Data s =>
(forall d. Data d => d -> u) -> Lexeme s -> [u]
forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Lexeme s)
forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lexeme s -> c (Lexeme s)
forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Lexeme s))
forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Lexeme s))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Lexeme s -> u
forall u. (forall d. Data d => d -> u) -> Lexeme s -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Lexeme s)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lexeme s -> c (Lexeme s)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Lexeme s))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Lexeme s))
$cgfoldl :: forall s (c :: * -> *).
Data s =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lexeme s -> c (Lexeme s)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lexeme s -> c (Lexeme s)
$cgunfold :: forall s (c :: * -> *).
Data s =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Lexeme s)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Lexeme s)
$ctoConstr :: forall s. Data s => Lexeme s -> Constr
toConstr :: Lexeme s -> Constr
$cdataTypeOf :: forall s. Data s => Lexeme s -> DataType
dataTypeOf :: Lexeme s -> DataType
$cdataCast1 :: forall s (t :: * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Lexeme s))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Lexeme s))
$cdataCast2 :: forall s (t :: * -> * -> *) (c :: * -> *).
(Data s, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Lexeme s))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Lexeme s))
$cgmapT :: forall s.
Data s =>
(forall b. Data b => b -> b) -> Lexeme s -> Lexeme s
gmapT :: (forall b. Data b => b -> b) -> Lexeme s -> Lexeme s
$cgmapQl :: forall s r r'.
Data s =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
$cgmapQr :: forall s r r'.
Data s =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Lexeme s -> r
$cgmapQ :: forall s u.
Data s =>
(forall d. Data d => d -> u) -> Lexeme s -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Lexeme s -> [u]
$cgmapQi :: forall s u.
Data s =>
Int -> (forall d. Data d => d -> u) -> Lexeme s -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lexeme s -> u
$cgmapM :: forall s (m :: * -> *).
(Data s, Monad m) =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
$cgmapMp :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
$cgmapMo :: forall s (m :: * -> *).
(Data s, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lexeme s -> m (Lexeme s)
Data, Lexeme s -> Lexeme s -> Bool
(Lexeme s -> Lexeme s -> Bool)
-> (Lexeme s -> Lexeme s -> Bool) -> Eq (Lexeme s)
forall s. Eq s => Lexeme s -> Lexeme s -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall s. Eq s => Lexeme s -> Lexeme s -> Bool
== :: Lexeme s -> Lexeme s -> Bool
$c/= :: forall s. Eq s => Lexeme s -> Lexeme s -> Bool
/= :: Lexeme s -> Lexeme s -> Bool
Eq, (forall a b. (a -> b) -> Lexeme a -> Lexeme b)
-> (forall a b. a -> Lexeme b -> Lexeme a) -> Functor Lexeme
forall a b. a -> Lexeme b -> Lexeme a
forall a b. (a -> b) -> Lexeme a -> Lexeme b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Lexeme a -> Lexeme b
fmap :: forall a b. (a -> b) -> Lexeme a -> Lexeme b
$c<$ :: forall a b. a -> Lexeme b -> Lexeme a
<$ :: forall a b. a -> Lexeme b -> Lexeme a
Functor, Int -> Lexeme s -> ShowS
[Lexeme s] -> ShowS
Lexeme s -> String
(Int -> Lexeme s -> ShowS)
-> (Lexeme s -> String) -> ([Lexeme s] -> ShowS) -> Show (Lexeme s)
forall s. Show s => Int -> Lexeme s -> ShowS
forall s. Show s => [Lexeme s] -> ShowS
forall s. Show s => Lexeme s -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall s. Show s => Int -> Lexeme s -> ShowS
showsPrec :: Int -> Lexeme s -> ShowS
$cshow :: forall s. Show s => Lexeme s -> String
show :: Lexeme s -> String
$cshowList :: forall s. Show s => [Lexeme s] -> ShowS
showList :: [Lexeme s] -> ShowS
Show)

data TokenType = Delimiter | Keyword | Operator | Modifier | Other
               deriving (Typeable TokenType
Typeable TokenType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TokenType -> c TokenType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TokenType)
-> (TokenType -> Constr)
-> (TokenType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TokenType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenType))
-> ((forall b. Data b => b -> b) -> TokenType -> TokenType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TokenType -> r)
-> (forall u. (forall d. Data d => d -> u) -> TokenType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TokenType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TokenType -> m TokenType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenType -> m TokenType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TokenType -> m TokenType)
-> Data TokenType
TokenType -> Constr
TokenType -> DataType
(forall b. Data b => b -> b) -> TokenType -> TokenType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TokenType -> u
forall u. (forall d. Data d => d -> u) -> TokenType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenType -> c TokenType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenType -> c TokenType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TokenType -> c TokenType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TokenType
$ctoConstr :: TokenType -> Constr
toConstr :: TokenType -> Constr
$cdataTypeOf :: TokenType -> DataType
dataTypeOf :: TokenType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TokenType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TokenType)
$cgmapT :: (forall b. Data b => b -> b) -> TokenType -> TokenType
gmapT :: (forall b. Data b => b -> b) -> TokenType -> TokenType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TokenType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TokenType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TokenType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TokenType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TokenType -> m TokenType
Data, TokenType -> TokenType -> Bool
(TokenType -> TokenType -> Bool)
-> (TokenType -> TokenType -> Bool) -> Eq TokenType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TokenType -> TokenType -> Bool
== :: TokenType -> TokenType -> Bool
$c/= :: TokenType -> TokenType -> Bool
/= :: TokenType -> TokenType -> Bool
Eq, Int -> TokenType -> ShowS
[TokenType] -> ShowS
TokenType -> String
(Int -> TokenType -> ShowS)
-> (TokenType -> String)
-> ([TokenType] -> ShowS)
-> Show TokenType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TokenType -> ShowS
showsPrec :: Int -> TokenType -> ShowS
$cshow :: TokenType -> String
show :: TokenType -> String
$cshowList :: [TokenType] -> ShowS
showList :: [TokenType] -> ShowS
Show)

-- | Re-calculates the position of every node in the parse tree from the tokens stored with it and its children.
adjustPositions :: (Factorial s, Position pos, Rank2.Foldable (g (Const (Sum Int))),
                    Deep.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g,
                    Deep.Traversable (PositionAdjustment pos s) g)
                => Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
                -> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
adjustPositions :: forall s pos (g :: (* -> *) -> (* -> *) -> *).
(Factorial s, Position pos, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Wrapped pos s) (Sum Int)) g,
 Traversable (PositionAdjustment pos s) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
-> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
adjustPositions Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
node = State Int (Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)))
-> Int -> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
forall s a. State s a -> s -> a
evalState (PositionAdjustment pos s
-> Domain
     (PositionAdjustment pos s)
     (g (Domain (PositionAdjustment pos s))
        (Domain (PositionAdjustment pos s)))
-> State Int (Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)))
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> Domain t (g (Domain t) (Domain t)) -> m (f (g f f))
forall (m :: * -> *) (f :: * -> *).
(Codomain (PositionAdjustment pos s) ~ Compose m f) =>
PositionAdjustment pos s
-> Domain
     (PositionAdjustment pos s)
     (g (Domain (PositionAdjustment pos s))
        (Domain (PositionAdjustment pos s)))
-> m (f (g f f))
Full.traverse PositionAdjustment pos s
forall pos s. PositionAdjustment pos s
PositionAdjustment Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
Domain
  (PositionAdjustment pos s)
  (g (Domain (PositionAdjustment pos s))
     (Domain (PositionAdjustment pos s)))
node) Int
0

-- | Serializes the tree back into the text it was parsed from.
reserialize :: (Monoid s, Factorial s, Position pos, Deep.Foldable (Serialization pos s) g)
            => Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> s
reserialize :: forall s pos (g :: (* -> *) -> (* -> *) -> *).
(Monoid s, Factorial s, Position pos,
 Foldable (Serialization pos s) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> s
reserialize = (Lexeme s -> s) -> [Lexeme s] -> s
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Lexeme s -> s
forall s. Lexeme s -> s
lexemeText ([Lexeme s] -> s)
-> (Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
    -> [Lexeme s])
-> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
-> s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> [Lexeme s]
forall s pos (g :: (* -> *) -> (* -> *) -> *).
(Factorial s, Position pos, Foldable (Serialization pos s) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> [Lexeme s]
lexemes

-- | Serializes the tree just like 'reserialize', but with an additional wrapping on every node.
reserializeNested :: (Monoid s, Factorial s, Position pos, Foldable f,
                      Deep.Foldable (Transformation.Folded f (Serialization pos s)) g)
                  => Compose f (Wrapped pos s) (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))) -> s
reserializeNested :: forall s pos (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *).
(Monoid s, Factorial s, Position pos, Foldable f,
 Foldable (Folded f (Serialization pos s)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> s
reserializeNested = (Lexeme s -> s) -> [Lexeme s] -> s
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Lexeme s -> s
forall s. Lexeme s -> s
lexemeText ([Lexeme s] -> s)
-> (Compose
      f
      (Wrapped pos s)
      (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
    -> [Lexeme s])
-> Compose
     f
     (Wrapped pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> [Lexeme s]
forall s pos (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *).
(Factorial s, Position pos, Foldable f,
 Foldable (Folded f (Serialization pos s)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> [Lexeme s]
nestedLexemes

-- | Serializes the tree into the lexemes it was parsed from.
lexemes :: (Factorial s, Position pos, Deep.Foldable (Serialization pos s) g)
        => Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> [Lexeme s]
lexemes :: forall s pos (g :: (* -> *) -> (* -> *) -> *).
(Factorial s, Position pos, Foldable (Serialization pos s) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> [Lexeme s]
lexemes Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
root = PositionedLexemes pos s -> [Lexeme s]
forall {c} {s}. PositionedLexemes c s -> [Lexeme s]
finalize (PositionedLexemes pos s -> [Lexeme s])
-> PositionedLexemes pos s -> [Lexeme s]
forall a b. (a -> b) -> a -> b
$ Serialization pos s
-> Domain
     (Serialization pos s)
     (g (Domain (Serialization pos s)) (Domain (Serialization pos s)))
-> PositionedLexemes pos s
forall m.
(Codomain (Serialization pos s) ~ Const m, Monoid m) =>
Serialization pos s
-> Domain
     (Serialization pos s)
     (g (Domain (Serialization pos s)) (Domain (Serialization pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap Serialization pos s
forall pos s. Serialization pos s
Serialization Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
Domain
  (Serialization pos s)
  (g (Domain (Serialization pos s)) (Domain (Serialization pos s)))
root
   where finalize :: PositionedLexemes c s -> [Lexeme s]
finalize (PositionedLexemes Seq (c, ParsedLexemes s, c)
ranges) = ((c, ParsedLexemes s, c) -> [Lexeme s])
-> Seq (c, ParsedLexemes s, c) -> [Lexeme s]
forall m a. Monoid m => (a -> m) -> Seq a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (c, ParsedLexemes s, c) -> [Lexeme s]
forall {a} {s} {c}. (a, ParsedLexemes s, c) -> [Lexeme s]
lexemeList Seq (c, ParsedLexemes s, c)
ranges
         lexemeList :: (a, ParsedLexemes s, c) -> [Lexeme s]
lexemeList (a
_, Trailing [Lexeme s]
ls, c
_) = [Lexeme s]
ls

-- | Serializes the tree into the lexemes it was parsed from.
nestedLexemes :: (Factorial s, Position pos, Foldable f,
                  Deep.Foldable (Transformation.Folded f (Serialization pos s)) g)
              => Compose f (Wrapped pos s) (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))) -> [Lexeme s]
nestedLexemes :: forall s pos (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *).
(Factorial s, Position pos, Foldable f,
 Foldable (Folded f (Serialization pos s)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> [Lexeme s]
nestedLexemes Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root = PositionedLexemes pos s -> [Lexeme s]
forall {c} {s}. PositionedLexemes c s -> [Lexeme s]
finalize (PositionedLexemes pos s -> [Lexeme s])
-> PositionedLexemes pos s -> [Lexeme s]
forall a b. (a -> b) -> a -> b
$ Folded f (Serialization pos s)
-> Domain
     (Folded f (Serialization pos s))
     (g (Domain (Folded f (Serialization pos s)))
        (Domain (Folded f (Serialization pos s))))
-> PositionedLexemes pos s
forall m.
(Codomain (Folded f (Serialization pos s)) ~ Const m, Monoid m) =>
Folded f (Serialization pos s)
-> Domain
     (Folded f (Serialization pos s))
     (g (Domain (Folded f (Serialization pos s)))
        (Domain (Folded f (Serialization pos s))))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(Foldable t g, Codomain t ~ Const m, Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMap (Serialization pos s -> Folded f (Serialization pos s)
forall (f :: * -> *) t. t -> Folded f t
Transformation.Folded Serialization pos s
forall pos s. Serialization pos s
Serialization) Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
Domain
  (Folded f (Serialization pos s))
  (g (Domain (Folded f (Serialization pos s)))
     (Domain (Folded f (Serialization pos s))))
root
   where finalize :: PositionedLexemes c s -> [Lexeme s]
finalize (PositionedLexemes Seq (c, ParsedLexemes s, c)
ranges) = ((c, ParsedLexemes s, c) -> [Lexeme s])
-> Seq (c, ParsedLexemes s, c) -> [Lexeme s]
forall m a. Monoid m => (a -> m) -> Seq a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (c, ParsedLexemes s, c) -> [Lexeme s]
forall {a} {s} {c}. (a, ParsedLexemes s, c) -> [Lexeme s]
lexemeList Seq (c, ParsedLexemes s, c)
ranges
         lexemeList :: (a, ParsedLexemes s, c) -> [Lexeme s]
lexemeList (a
_, Trailing [Lexeme s]
ls, c
_) = [Lexeme s]
ls

-- | The length of the source code parsed into the argument node
sourceLength :: forall g s pos. (Factorial s, Rank2.Foldable (g (Const (Sum Int))),
                                 Deep.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g)
             => Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Int
sourceLength :: forall (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Wrapped pos s) (Sum Int)) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Int
sourceLength Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
root = Sum Int -> Int
forall a. Sum a -> a
getSum (Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Sum Int
forall {b} {a} {c} {b}.
Factorial b =>
((a, ParsedLexemes b, c), b) -> Sum Int
nodeLength Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
root Sum Int -> Sum Int -> Sum Int
forall a. Semigroup a => a -> a -> a
<> (g (Wrapped pos s) (Wrapped pos s) -> Sum Int)
-> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Sum Int
forall m a.
Monoid m =>
(a -> m) -> ((pos, ParsedLexemes s, pos), a) -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((forall a. Wrapped pos s a -> Sum Int)
-> g (Wrapped pos s) (Wrapped pos s) -> Sum Int
forall (p :: * -> *) m (g :: (* -> *) -> (* -> *) -> *).
(Foldable (Fold p m) g, Monoid m) =>
(forall a. p a -> m) -> g p p -> m
Transformation.Rank2.foldMap ((pos, ParsedLexemes s, pos), a) -> Sum Int
forall a. Wrapped pos s a -> Sum Int
forall {b} {a} {c} {b}.
Factorial b =>
((a, ParsedLexemes b, c), b) -> Sum Int
nodeLength) Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
root)
   where nodeLength :: ((a, ParsedLexemes b, c), b) -> Sum Int
nodeLength ((a
_, Trailing [Lexeme b]
ls, c
_), b
_) = (Lexeme b -> Sum Int) -> [Lexeme b] -> Sum Int
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Int -> Sum Int
forall a. a -> Sum a
Sum (Int -> Sum Int) -> (Lexeme b -> Int) -> Lexeme b -> Sum Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Int
forall m. Factorial m => m -> Int
Factorial.length (b -> Int) -> (Lexeme b -> b) -> Lexeme b -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme b -> b
forall s. Lexeme s -> s
lexemeText) [Lexeme b]
ls

-- | The length of the parsed source code with nodes 'Wrapped' under a nested wrapper
nestedSourceLength :: forall f g s pos.
                      (Factorial s, Foldable f, Rank2.Foldable (g (Const (Sum Int))),
                       Deep.Foldable (Transformation.Rank2.Fold (Compose f (Wrapped pos s)) (Sum Int)) g)
                   => Compose f (Wrapped pos s) (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))) -> Int
nestedSourceLength :: forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable f, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Compose f (Wrapped pos s)) (Sum Int)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
nestedSourceLength Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root = Sum Int -> Int
forall a. Sum a -> a
getSum (Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Sum Int
forall {t :: * -> *} {b} {a} {c} {b}.
(Foldable t, Factorial b) =>
Compose t ((,) (a, ParsedLexemes b, c)) b -> Sum Int
nestedNodeLength Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root Sum Int -> Sum Int -> Sum Int
forall a. Semigroup a => a -> a -> a
<> (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
 -> Sum Int)
-> Compose
     f
     (Wrapped pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Sum Int
forall m a.
Monoid m =>
(a -> m) -> Compose f (Wrapped pos s) a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((forall a. Compose f (Wrapped pos s) a -> Sum Int)
-> g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
-> Sum Int
forall (p :: * -> *) m (g :: (* -> *) -> (* -> *) -> *).
(Foldable (Fold p m) g, Monoid m) =>
(forall a. p a -> m) -> g p p -> m
Transformation.Rank2.foldMap Compose f (Wrapped pos s) a -> Sum Int
forall a. Compose f (Wrapped pos s) a -> Sum Int
forall {t :: * -> *} {b} {a} {c} {b}.
(Foldable t, Factorial b) =>
Compose t ((,) (a, ParsedLexemes b, c)) b -> Sum Int
nestedNodeLength) Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root)
   where nestedNodeLength :: Compose t ((,) (a, ParsedLexemes b, c)) b -> Sum Int
nestedNodeLength (Compose t ((a, ParsedLexemes b, c), b)
node) = (((a, ParsedLexemes b, c), b) -> Sum Int)
-> t ((a, ParsedLexemes b, c), b) -> Sum Int
forall m a. Monoid m => (a -> m) -> t a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((a, ParsedLexemes b, c), b) -> Sum Int
forall {b} {a} {c} {b}.
Factorial b =>
((a, ParsedLexemes b, c), b) -> Sum Int
nodeLength t ((a, ParsedLexemes b, c), b)
node
         nodeLength :: ((a, ParsedLexemes b, c), b) -> Sum Int
nodeLength ((a
_, Trailing [Lexeme b]
ls, c
_), b
_) = (Lexeme b -> Sum Int) -> [Lexeme b] -> Sum Int
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Int -> Sum Int
forall a. a -> Sum a
Sum (Int -> Sum Int) -> (Lexeme b -> Int) -> Lexeme b -> Sum Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Int
forall m. Factorial m => m -> Int
Factorial.length (b -> Int) -> (Lexeme b -> b) -> Lexeme b -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lexeme b -> b
forall s. Lexeme s -> s
lexemeText) [Lexeme b]
ls

-- | Join the two wrappings of a double-'Wrapped' value into one.
joinWrapped :: (Position pos, Factorial s) => Wrapped pos s (Wrapped pos s a) -> Wrapped pos s a
joinWrapped :: forall pos s a.
(Position pos, Factorial s) =>
Wrapped pos s (Wrapped pos s a) -> Wrapped pos s a
joinWrapped ((pos
start, Trailing [Lexeme s]
lexemes, pos
end), ((pos
innerStart, Trailing [Lexeme s]
innerLexemes, pos
innerEnd), a
x)) =
   ((pos
start, [Lexeme s] -> ParsedLexemes s
forall s. [Lexeme s] -> ParsedLexemes s
Trailing ([Lexeme s] -> ParsedLexemes s) -> [Lexeme s] -> ParsedLexemes s
forall a b. (a -> b) -> a -> b
$ pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
forall pos s.
(Position pos, Factorial s) =>
pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
mergeLexemes pos
start [Lexeme s]
lexemes pos
innerStart [Lexeme s]
innerLexemes, pos
end), a
x)

-- | Given two lists of lexemes where the first wraps the second and their starting positions, return a single list
-- sorted by position.
mergeLexemes :: (Position pos, Factorial s) => pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
mergeLexemes :: forall pos s.
(Position pos, Factorial s) =>
pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
mergeLexemes pos
pos1 outer :: [Lexeme s]
outer@(Lexeme s
lexeme1:[Lexeme s]
rest1) pos
pos2 inner :: [Lexeme s]
inner@(Lexeme s
lexeme2:[Lexeme s]
rest2)
   | pos
pos1 pos -> pos -> Bool
forall a. Ord a => a -> a -> Bool
< pos
pos2 = Lexeme s
lexeme1 Lexeme s -> [Lexeme s] -> [Lexeme s]
forall a. a -> [a] -> [a]
: pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
forall pos s.
(Position pos, Factorial s) =>
pos -> [Lexeme s] -> pos -> [Lexeme s] -> [Lexeme s]
mergeLexemes (Int -> pos -> pos
forall p. Position p => Int -> p -> p
move (s -> Int
forall m. Factorial m => m -> Int
Factorial.length (s -> Int) -> s -> Int
forall a b. (a -> b) -> a -> b
$ Lexeme s -> s
forall s. Lexeme s -> s
lexemeText Lexeme s
lexeme1) pos
pos1) [Lexeme s]
rest1 pos
pos2 [Lexeme s]
inner
mergeLexemes pos
_ [Lexeme s]
outer pos
_ [Lexeme s]
inner = [Lexeme s]
inner [Lexeme s] -> [Lexeme s] -> [Lexeme s]
forall a. Semigroup a => a -> a -> a
<> [Lexeme s]
outer

-- | Transformation type used by 'reserialize'
data Serialization pos s = Serialization
-- | Transformation type used by 'adjustPositions'
data PositionAdjustment pos s = PositionAdjustment
data NestedPositionAdjustment (f :: Type -> Type) pos s = NestedPositionAdjustment

-- | Map the stored positions and lexeme inputs in the entire tree and its wrapping
mapWrappings :: Deep.Functor (Transformation.Rank2.Map (Wrapped pos s) (Wrapped pos' s')) g
             => (pos -> pos') -> (s -> s')
             -> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
             -> Wrapped pos' s' (g (Wrapped pos' s') (Wrapped pos' s'))
mapWrappings :: forall pos s pos' s' (g :: (* -> *) -> (* -> *) -> *).
Functor (Map (Wrapped pos s) (Wrapped pos' s')) g =>
(pos -> pos')
-> (s -> s')
-> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
-> Wrapped pos' s' (g (Wrapped pos' s') (Wrapped pos' s'))
mapWrappings pos -> pos'
f s -> s'
g Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
x = (pos -> pos')
-> (s -> s')
-> Wrapped pos s (g (Wrapped pos' s') (Wrapped pos' s'))
-> Wrapped pos' s' (g (Wrapped pos' s') (Wrapped pos' s'))
forall pos pos' s s' a.
(pos -> pos') -> (s -> s') -> Wrapped pos s a -> Wrapped pos' s' a
mapWrapping pos -> pos'
f s -> s'
g (((pos -> pos')
-> (s -> s')
-> ((pos, ParsedLexemes s, pos), a)
-> ((pos', ParsedLexemes s', pos'), a)
forall pos pos' s s' a.
(pos -> pos') -> (s -> s') -> Wrapped pos s a -> Wrapped pos' s' a
mapWrapping pos -> pos'
f s -> s'
g (forall {a}.
 ((pos, ParsedLexemes s, pos), a)
 -> ((pos', ParsedLexemes s', pos'), a))
-> g (Wrapped pos s) (Wrapped pos s)
-> g (Wrapped pos' s') (Wrapped pos' s')
forall (p :: * -> *) (q :: * -> *)
       (g :: (* -> *) -> (* -> *) -> *).
Functor (Map p q) g =>
(forall a. p a -> q a) -> g p p -> g q q
Transformation.Rank2.<$>) (g (Wrapped pos s) (Wrapped pos s)
 -> g (Wrapped pos' s') (Wrapped pos' s'))
-> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
-> Wrapped pos s (g (Wrapped pos' s') (Wrapped pos' s'))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Wrapped pos s (g (Wrapped pos s) (Wrapped pos s))
x)
{-# INLINE mapWrappings #-}

mapWrapping :: (pos -> pos') -> (s -> s') -> Wrapped pos s a -> Wrapped pos' s' a
mapWrapping :: forall pos pos' s s' a.
(pos -> pos') -> (s -> s') -> Wrapped pos s a -> Wrapped pos' s' a
mapWrapping pos -> pos'
f s -> s'
g ((pos
start, ParsedLexemes s
ls, pos
end), a
a) = ((pos -> pos'
f pos
start, s -> s'
g (s -> s') -> ParsedLexemes s -> ParsedLexemes s'
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsedLexemes s
ls, pos -> pos'
f pos
end), a
a)
{-# INLINE mapWrapping #-}

instance Transformation.Transformation (Serialization pos s) where
    type Domain (Serialization pos s) = Wrapped pos s
    type Codomain (Serialization pos s) = Const (PositionedLexemes pos s)

instance Transformation.Transformation (PositionAdjustment pos s) where
    type Domain (PositionAdjustment pos s) = Wrapped pos s
    type Codomain (PositionAdjustment pos s) = Compose (State Int) (Wrapped pos s)

instance Transformation.Transformation (NestedPositionAdjustment f pos s) where
    type Domain (NestedPositionAdjustment f pos s) = Compose f (Wrapped pos s)
    type Codomain (NestedPositionAdjustment f pos s) = Compose (State Int) (Compose f (Wrapped pos s))

newtype PositionedLexemes pos s = PositionedLexemes (Seq (pos, ParsedLexemes s, pos))

instance (Factorial s, Position pos) => Semigroup (PositionedLexemes pos s) where
   PositionedLexemes Seq (pos, ParsedLexemes s, pos)
ranges1 <> :: PositionedLexemes pos s
-> PositionedLexemes pos s -> PositionedLexemes pos s
<> PositionedLexemes Seq (pos, ParsedLexemes s, pos)
ranges2 = ViewR (pos, ParsedLexemes s, pos)
-> ViewL (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall s pos.
(Factorial s, Position pos) =>
ViewR (pos, ParsedLexemes s, pos)
-> ViewL (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
combine (Seq (pos, ParsedLexemes s, pos)
-> ViewR (pos, ParsedLexemes s, pos)
forall a. Seq a -> ViewR a
Seq.viewr Seq (pos, ParsedLexemes s, pos)
ranges1) (Seq (pos, ParsedLexemes s, pos)
-> ViewL (pos, ParsedLexemes s, pos)
forall a. Seq a -> ViewL a
Seq.viewl Seq (pos, ParsedLexemes s, pos)
ranges2)

combine :: (Factorial s, Position pos)
        => Seq.ViewR (pos, ParsedLexemes s, pos) -> Seq.ViewL (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
combine :: forall s pos.
(Factorial s, Position pos) =>
ViewR (pos, ParsedLexemes s, pos)
-> ViewL (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
combine (Seq (pos, ParsedLexemes s, pos)
ranges1 Seq.:> range1 :: (pos, ParsedLexemes s, pos)
range1@(pos
start1, ParsedLexemes s
ls1, pos
end1)) (range2 :: (pos, ParsedLexemes s, pos)
range2@(pos
start2, ParsedLexemes s
ls2, pos
end2) Seq.:< Seq (pos, ParsedLexemes s, pos)
ranges2)
   | pos
end1 pos -> pos -> Bool
forall a. Eq a => a -> a -> Bool
== pos
start2 = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes (Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s)
-> Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall a b. (a -> b) -> a -> b
$ Seq (pos, ParsedLexemes s, pos)
ranges1 Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. Semigroup a => a -> a -> a
<> (pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (pos
start1, ParsedLexemes s
ls1 ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall a. Semigroup a => a -> a -> a
<> ParsedLexemes s
ls2, pos
end2) Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. Semigroup a => a -> a -> a
<> Seq (pos, ParsedLexemes s, pos)
ranges2
   | pos
end1 pos -> pos -> Bool
forall a. Ord a => a -> a -> Bool
< pos
start2 = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes (Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s)
-> Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall a b. (a -> b) -> a -> b
$ Seq (pos, ParsedLexemes s, pos)
ranges1 Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. Semigroup a => a -> a -> a
<> (pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (pos, ParsedLexemes s, pos)
range1 Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. Semigroup a => a -> a -> a
<> (pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (pos, ParsedLexemes s, pos)
range2 Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. Semigroup a => a -> a -> a
<> Seq (pos, ParsedLexemes s, pos)
ranges2
   | (ParsedLexemes s
ls1p, ParsedLexemes s
ls1s) <- pos -> ParsedLexemes s -> pos -> (ParsedLexemes s, ParsedLexemes s)
forall {t} {s}.
(Position t, Factorial s) =>
t -> ParsedLexemes s -> t -> (ParsedLexemes s, ParsedLexemes s)
splitUntil pos
start1 ParsedLexemes s
ls1 pos
start2 =
        Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes Seq (pos, ParsedLexemes s, pos)
ranges1
        PositionedLexemes pos s
-> PositionedLexemes pos s -> PositionedLexemes pos s
forall a. Semigroup a => a -> a -> a
<> (Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes ((pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (pos
start1, ParsedLexemes s
ls1p ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall a. Semigroup a => a -> a -> a
<> ParsedLexemes s
ls2 ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall a. Semigroup a => a -> a -> a
<> ParsedLexemes s
ls1s, pos
end1)) PositionedLexemes pos s
-> PositionedLexemes pos s -> PositionedLexemes pos s
forall a. Semigroup a => a -> a -> a
<> Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes Seq (pos, ParsedLexemes s, pos)
ranges2)
combine (Seq (pos, ParsedLexemes s, pos)
ranges Seq.:> (pos, ParsedLexemes s, pos)
range) ViewL (pos, ParsedLexemes s, pos)
Seq.EmptyL = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes (Seq (pos, ParsedLexemes s, pos)
ranges Seq (pos, ParsedLexemes s, pos)
-> (pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. Seq a -> a -> Seq a
Seq.|> (pos, ParsedLexemes s, pos)
range)
combine ViewR (pos, ParsedLexemes s, pos)
Seq.EmptyR ((pos, ParsedLexemes s, pos)
range Seq.:< Seq (pos, ParsedLexemes s, pos)
ranges) = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes ((pos, ParsedLexemes s, pos)
range (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
-> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a -> Seq a
Seq.<| Seq (pos, ParsedLexemes s, pos)
ranges)
combine ViewR (pos, ParsedLexemes s, pos)
Seq.EmptyR ViewL (pos, ParsedLexemes s, pos)
Seq.EmptyL = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes Seq (pos, ParsedLexemes s, pos)
forall a. Monoid a => a
mempty

splitUntil :: t -> ParsedLexemes s -> t -> (ParsedLexemes s, ParsedLexemes s)
splitUntil t
start ParsedLexemes s
lexemes t
end
   | t
start t -> t -> Bool
forall a. Ord a => a -> a -> Bool
< t
end, Trailing (Lexeme s
l:[Lexeme s]
ls) <- ParsedLexemes s
lexemes =
        (ParsedLexemes s -> ParsedLexemes s)
-> (ParsedLexemes s, ParsedLexemes s)
-> (ParsedLexemes s, ParsedLexemes s)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first ([Lexeme s] -> ParsedLexemes s
forall s. [Lexeme s] -> ParsedLexemes s
Trailing [Lexeme s
l] ParsedLexemes s -> ParsedLexemes s -> ParsedLexemes s
forall a. Semigroup a => a -> a -> a
<>) (t -> ParsedLexemes s -> t -> (ParsedLexemes s, ParsedLexemes s)
splitUntil (Int -> t -> t
forall p. Position p => Int -> p -> p
move (s -> Int
forall m. Factorial m => m -> Int
Factorial.length (Lexeme s -> s
forall s. Lexeme s -> s
lexemeText Lexeme s
l)) t
start) ([Lexeme s] -> ParsedLexemes s
forall s. [Lexeme s] -> ParsedLexemes s
Trailing [Lexeme s]
ls) t
end)
   | Bool
otherwise = (ParsedLexemes s
forall a. Monoid a => a
mempty, ParsedLexemes s
lexemes)

instance (Factorial s, Position pos) => Monoid (PositionedLexemes pos s) where
  mempty :: PositionedLexemes pos s
mempty = Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes Seq (pos, ParsedLexemes s, pos)
forall a. Monoid a => a
mempty

instance forall pos s a. (Factorial s, Position pos) => Serialization pos s `Transformation.At` a where
   Serialization pos s
Serialization $ :: Serialization pos s
-> Domain (Serialization pos s) a
-> Codomain (Serialization pos s) a
$ ((pos, ParsedLexemes s, pos)
range, a
_) = PositionedLexemes pos s -> Const (PositionedLexemes pos s) a
forall {k} a (b :: k). a -> Const a b
Const (Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall pos s.
Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
PositionedLexemes (Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s)
-> Seq (pos, ParsedLexemes s, pos) -> PositionedLexemes pos s
forall a b. (a -> b) -> a -> b
$ (pos, ParsedLexemes s, pos) -> Seq (pos, ParsedLexemes s, pos)
forall a. a -> Seq a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (pos, ParsedLexemes s, pos)
range)

instance forall g s pos. (Factorial s, Position pos,
                          Rank2.Foldable (g (Wrapped pos s)), Deep.Foldable (Serialization pos s) g) =>
         Full.Foldable (Serialization pos s) g where
   foldMap :: forall m.
(Codomain (Serialization pos s) ~ Const m, Monoid m) =>
Serialization pos s
-> Domain
     (Serialization pos s)
     (g (Domain (Serialization pos s)) (Domain (Serialization pos s)))
-> m
foldMap = Serialization pos s
-> Domain
     (Serialization pos s)
     (g (Domain (Serialization pos s)) (Domain (Serialization pos s)))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Factorial s, Rank2.Foldable (g (Const (Sum Int))), Position pos,
          Deep.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g) =>
         PositionAdjustment pos s `Transformation.At` g (Wrapped pos s) (Wrapped pos s) where
   PositionAdjustment pos s
PositionAdjustment $ :: PositionAdjustment pos s
-> Domain
     (PositionAdjustment pos s) (g (Wrapped pos s) (Wrapped pos s))
-> Codomain
     (PositionAdjustment pos s) (g (Wrapped pos s) (Wrapped pos s))
$ root :: Domain
  (PositionAdjustment pos s) (g (Wrapped pos s) (Wrapped pos s))
root@((pos
nodeStart, ParsedLexemes s
lexemes, pos
nodeEnd), g (Wrapped pos s) (Wrapped pos s)
node) = StateT
  Int
  Identity
  ((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
-> Compose
     (StateT Int Identity)
     (Wrapped pos s)
     (g (Wrapped pos s) (Wrapped pos s))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose ((Int
 -> (((pos, ParsedLexemes s, pos),
      g (Wrapped pos s) (Wrapped pos s)),
     Int))
-> StateT
     Int
     Identity
     ((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state Int
-> (((pos, ParsedLexemes s, pos),
     g (Wrapped pos s) (Wrapped pos s)),
    Int)
f)
      where f :: Int -> (Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)), Int)
            f :: Int
-> (((pos, ParsedLexemes s, pos),
     g (Wrapped pos s) (Wrapped pos s)),
    Int)
f Int
adjustment = (((Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeStart, ParsedLexemes s
lexemes, Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeEnd'), g (Wrapped pos s) (Wrapped pos s)
node),
                            Int
adjustment Int -> Int -> Int
forall a. Num a => a -> a -> a
+ pos -> pos -> Int
forall p. Position p => p -> p -> Int
distance pos
nodeEnd pos
nodeEnd')
               where nodeEnd' :: pos
nodeEnd' = Int -> pos -> pos
forall p. Position p => Int -> p -> p
move (((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
-> Int
forall (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Wrapped pos s) (Sum Int)) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Int
sourceLength ((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
Domain
  (PositionAdjustment pos s) (g (Wrapped pos s) (Wrapped pos s))
root) pos
nodeStart

instance (Factorial s, Rank2.Foldable (g (Const (Sum Int))), Rank2.Traversable (g (Wrapped pos s)), Position pos,
          Deep.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g,
          Deep.Traversable (PositionAdjustment pos s) g) => Full.Traversable (PositionAdjustment pos s) g where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain (PositionAdjustment pos s) ~ Compose m f) =>
PositionAdjustment pos s
-> Domain
     (PositionAdjustment pos s)
     (g (Domain (PositionAdjustment pos s))
        (Domain (PositionAdjustment pos s)))
-> m (f (g f f))
traverse PositionAdjustment pos s
PositionAdjustment root :: Domain
  (PositionAdjustment pos s)
  (g (Domain (PositionAdjustment pos s))
     (Domain (PositionAdjustment pos s)))
root@((pos
nodeStart, ParsedLexemes s
lexemes, pos
nodeEnd), g (Wrapped pos s) (Wrapped pos s)
node) = (Int -> (f (g f f), Int)) -> StateT Int Identity (f (g f f))
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state Int -> (f (g f f), Int)
Int -> (((pos, ParsedLexemes s, pos), g f f), Int)
f
      where f :: Int -> (((pos, ParsedLexemes s, pos), g f f), Int)
f Int
adjustment = (((Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeStart, ParsedLexemes s
lexemes, Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeEnd'),
                             State Int (g f f) -> Int -> g f f
forall s a. State s a -> s -> a
evalState (PositionAdjustment pos s
-> g (Domain (PositionAdjustment pos s))
     (Domain (PositionAdjustment pos s))
-> State Int (g f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain (PositionAdjustment pos s) ~ Compose m f) =>
PositionAdjustment pos s
-> g (Domain (PositionAdjustment pos s))
     (Domain (PositionAdjustment pos s))
-> m (g f f)
Deep.traverse PositionAdjustment pos s
forall pos s. PositionAdjustment pos s
PositionAdjustment g (Wrapped pos s) (Wrapped pos s)
g (Domain (PositionAdjustment pos s))
  (Domain (PositionAdjustment pos s))
node) Int
adjustment),
                            Int
adjustment Int -> Int -> Int
forall a. Num a => a -> a -> a
+ pos -> pos -> Int
forall p. Position p => p -> p -> Int
distance pos
nodeEnd pos
nodeEnd')
               where nodeEnd' :: pos
nodeEnd' = Int -> pos -> pos
forall p. Position p => Int -> p -> p
move (((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
-> Int
forall (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Wrapped pos s) (Sum Int)) g) =>
Wrapped pos s (g (Wrapped pos s) (Wrapped pos s)) -> Int
sourceLength ((pos, ParsedLexemes s, pos), g (Wrapped pos s) (Wrapped pos s))
Domain
  (PositionAdjustment pos s)
  (g (Domain (PositionAdjustment pos s))
     (Domain (PositionAdjustment pos s)))
root) pos
nodeStart

instance (Rank2.Foldable (g (Wrapped pos s)),
          Deep.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g) =>
         Full.Foldable (Transformation.Rank2.Fold (Wrapped pos s) (Sum Int)) g where
   foldMap :: forall m.
(Codomain (Fold (Wrapped pos s) (Sum Int)) ~ Const m, Monoid m) =>
Fold (Wrapped pos s) (Sum Int)
-> Domain
     (Fold (Wrapped pos s) (Sum Int))
     (g (Domain (Fold (Wrapped pos s) (Sum Int)))
        (Domain (Fold (Wrapped pos s) (Sum Int))))
-> m
foldMap = Fold (Wrapped pos s) (Sum Int)
-> Domain
     (Fold (Wrapped pos s) (Sum Int))
     (g (Domain (Fold (Wrapped pos s) (Sum Int)))
        (Domain (Fold (Wrapped pos s) (Sum Int))))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Factorial s, Traversable f, Rank2.Foldable (g (Const (Sum Int))), Position pos,
          Deep.Foldable (Transformation.Rank2.Fold (Compose f (Wrapped pos s)) (Sum Int)) g) =>
         NestedPositionAdjustment f pos s
         `Transformation.At` g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)) where
   NestedPositionAdjustment f pos s
NestedPositionAdjustment $ :: NestedPositionAdjustment f pos s
-> Domain
     (NestedPositionAdjustment f pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Codomain
     (NestedPositionAdjustment f pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
$ Domain
  (NestedPositionAdjustment f pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root = StateT
  Int
  Identity
  (Compose
     f
     (Wrapped pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> Compose
     (StateT Int Identity)
     (Compose f (Wrapped pos s))
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (StateT
   Int
   Identity
   (Compose
      f
      (Wrapped pos s)
      (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
 -> Compose
      (StateT Int Identity)
      (Compose f (Wrapped pos s))
      (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> StateT
     Int
     Identity
     (Compose
        f
        (Wrapped pos s)
        (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> Compose
     (StateT Int Identity)
     (Compose f (Wrapped pos s))
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall a b. (a -> b) -> a -> b
$ f ((pos, ParsedLexemes s, pos),
   g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Compose
     f
     (Wrapped pos s)
     (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (f ((pos, ParsedLexemes s, pos),
    g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
 -> Compose
      f
      (Wrapped pos s)
      (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> StateT
     Int
     Identity
     (f ((pos, ParsedLexemes s, pos),
         g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> StateT
     Int
     Identity
     (Compose
        f
        (Wrapped pos s)
        (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((pos, ParsedLexemes s, pos),
  g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
 -> StateT
      Int
      Identity
      ((pos, ParsedLexemes s, pos),
       g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> f ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> StateT
     Int
     Identity
     (f ((pos, ParsedLexemes s, pos),
         g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> f a -> f (f b)
traverse ((Int
 -> (((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))),
     Int))
-> StateT
     Int
     Identity
     ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state ((Int
  -> (((pos, ParsedLexemes s, pos),
       g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))),
      Int))
 -> StateT
      Int
      Identity
      ((pos, ParsedLexemes s, pos),
       g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))))
-> (((pos, ParsedLexemes s, pos),
     g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
    -> Int
    -> (((pos, ParsedLexemes s, pos),
         g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))),
        Int))
-> ((pos, ParsedLexemes s, pos),
    g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> StateT
     Int
     Identity
     ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, ParsedLexemes s, pos),
 g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
-> (((pos, ParsedLexemes s, pos),
     g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))),
    Int)
advance) (Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> f ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
Domain
  (NestedPositionAdjustment f pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root)
      where advance :: Wrapped pos s (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))) -> Int -> (Wrapped pos s (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))), Int)
            advance :: ((pos, ParsedLexemes s, pos),
 g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
-> (((pos, ParsedLexemes s, pos),
     g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))),
    Int)
advance ((pos
nodeStart, ParsedLexemes s
lexemes, pos
nodeEnd), g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
node) Int
adjustment =
               (((Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeStart, ParsedLexemes s
lexemes, Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeEnd'), g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
node),
                Int
adjustment Int -> Int -> Int
forall a. Num a => a -> a -> a
+ pos -> pos -> Int
forall p. Position p => p -> p -> Int
distance pos
nodeEnd pos
nodeEnd')
               where nodeEnd' :: pos
nodeEnd' = Int -> pos -> pos
forall p. Position p => Int -> p -> p
move (Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable f, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Compose f (Wrapped pos s)) (Sum Int)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
nestedSourceLength Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
Domain
  (NestedPositionAdjustment f pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
root) pos
nodeStart

instance (Factorial s, Position pos, Traversable f,
          Rank2.Foldable (g (Const (Sum Int))), Rank2.Traversable (g (Compose f (Wrapped pos s))),
          Deep.Foldable (Transformation.Rank2.Fold (Compose f (Wrapped pos s)) (Sum Int)) g,
          Deep.Traversable (NestedPositionAdjustment f pos s) g) => Full.Traversable (NestedPositionAdjustment f pos s) g where
   traverse :: forall (m :: * -> *) (f :: * -> *).
(Codomain (NestedPositionAdjustment f pos s) ~ Compose m f) =>
NestedPositionAdjustment f pos s
-> Domain
     (NestedPositionAdjustment f pos s)
     (g (Domain (NestedPositionAdjustment f pos s))
        (Domain (NestedPositionAdjustment f pos s)))
-> m (f (g f f))
traverse NestedPositionAdjustment f pos s
NestedPositionAdjustment Domain
  (NestedPositionAdjustment f pos s)
  (g (Domain (NestedPositionAdjustment f pos s))
     (Domain (NestedPositionAdjustment f pos s)))
root = f ((pos, ParsedLexemes s, pos), g f f) -> f (g f f)
f ((pos, ParsedLexemes s, pos), g f f)
-> Compose f (Wrapped pos s) (g f f)
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (f ((pos, ParsedLexemes s, pos), g f f) -> f (g f f))
-> m (f ((pos, ParsedLexemes s, pos), g f f)) -> m (f (g f f))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (((pos, ParsedLexemes s, pos),
  g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
 -> m ((pos, ParsedLexemes s, pos), g f f))
-> f ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> m (f ((pos, ParsedLexemes s, pos), g f f))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> f a -> f (f b)
traverse ((Int -> (((pos, ParsedLexemes s, pos), g f f), Int))
-> m ((pos, ParsedLexemes s, pos), g f f)
(Int -> (((pos, ParsedLexemes s, pos), g f f), Int))
-> StateT Int Identity ((pos, ParsedLexemes s, pos), g f f)
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state ((Int -> (((pos, ParsedLexemes s, pos), g f f), Int))
 -> m ((pos, ParsedLexemes s, pos), g f f))
-> (((pos, ParsedLexemes s, pos),
     g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
    -> Int -> (((pos, ParsedLexemes s, pos), g f f), Int))
-> ((pos, ParsedLexemes s, pos),
    g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> m ((pos, ParsedLexemes s, pos), g f f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((pos, ParsedLexemes s, pos),
 g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int -> (((pos, ParsedLexemes s, pos), g f f), Int)
advance) (Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> f ((pos, ParsedLexemes s, pos),
      g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
Domain
  (NestedPositionAdjustment f pos s)
  (g (Domain (NestedPositionAdjustment f pos s))
     (Domain (NestedPositionAdjustment f pos s)))
root)
      where advance :: ((pos, ParsedLexemes s, pos),
 g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int -> (((pos, ParsedLexemes s, pos), g f f), Int)
advance ((pos
nodeStart, ParsedLexemes s
lexemes, pos
nodeEnd), g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
node) Int
adjustment = (((Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeStart, ParsedLexemes s
lexemes, Int -> pos -> pos
forall p. Position p => Int -> p -> p
move Int
adjustment pos
nodeEnd'),
                             State Int (g f f) -> Int -> g f f
forall s a. State s a -> s -> a
evalState (NestedPositionAdjustment f pos s
-> g (Domain (NestedPositionAdjustment f pos s))
     (Domain (NestedPositionAdjustment f pos s))
-> State Int (g f f)
forall t (g :: (* -> *) -> (* -> *) -> *) (m :: * -> *)
       (f :: * -> *).
(Traversable t g, Codomain t ~ Compose m f) =>
t -> g (Domain t) (Domain t) -> m (g f f)
forall (m :: * -> *) (f :: * -> *).
(Codomain (NestedPositionAdjustment f pos s) ~ Compose m f) =>
NestedPositionAdjustment f pos s
-> g (Domain (NestedPositionAdjustment f pos s))
     (Domain (NestedPositionAdjustment f pos s))
-> m (g f f)
Deep.traverse NestedPositionAdjustment f pos s
forall (f :: * -> *) pos s. NestedPositionAdjustment f pos s
NestedPositionAdjustment g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s))
g (Domain (NestedPositionAdjustment f pos s))
  (Domain (NestedPositionAdjustment f pos s))
node) Int
adjustment),
                            Int
adjustment Int -> Int -> Int
forall a. Num a => a -> a -> a
+ pos -> pos -> Int
forall p. Position p => p -> p -> Int
distance pos
nodeEnd pos
nodeEnd')
               where nodeEnd' :: pos
nodeEnd' = Int -> pos -> pos
forall p. Position p => Int -> p -> p
move (Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
forall (f :: * -> *) (g :: (* -> *) -> (* -> *) -> *) s pos.
(Factorial s, Foldable f, Foldable (g (Const (Sum Int))),
 Foldable (Fold (Compose f (Wrapped pos s)) (Sum Int)) g) =>
Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
-> Int
nestedSourceLength Compose
  f
  (Wrapped pos s)
  (g (Compose f (Wrapped pos s)) (Compose f (Wrapped pos s)))
Domain
  (NestedPositionAdjustment f pos s)
  (g (Domain (NestedPositionAdjustment f pos s))
     (Domain (NestedPositionAdjustment f pos s)))
root) pos
nodeStart

instance (Traversable f, Rank2.Foldable (g (Wrapped pos s)), Rank2.Foldable (g (Compose f (Wrapped pos s))),
          Deep.Foldable (Transformation.Rank2.Fold (Compose f (Wrapped pos s)) (Sum Int)) g) =>
         Full.Foldable (Transformation.Rank2.Fold (Compose f (Wrapped pos s)) (Sum Int)) g where
   foldMap :: forall m.
(Codomain (Fold (Compose f (Wrapped pos s)) (Sum Int)) ~ Const m,
 Monoid m) =>
Fold (Compose f (Wrapped pos s)) (Sum Int)
-> Domain
     (Fold (Compose f (Wrapped pos s)) (Sum Int))
     (g (Domain (Fold (Compose f (Wrapped pos s)) (Sum Int)))
        (Domain (Fold (Compose f (Wrapped pos s)) (Sum Int))))
-> m
foldMap = Fold (Compose f (Wrapped pos s)) (Sum Int)
-> Domain
     (Fold (Compose f (Wrapped pos s)) (Sum Int))
     (g (Domain (Fold (Compose f (Wrapped pos s)) (Sum Int)))
        (Domain (Fold (Compose f (Wrapped pos s)) (Sum Int))))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault

instance (Factorial s, Position pos, Foldable f, Rank2.Foldable (g (Compose f (Wrapped pos s))),
          Deep.Foldable (Transformation.Folded f (Serialization pos s)) g) =>
         Full.Foldable (Transformation.Folded f (Serialization pos s)) g where
   foldMap :: forall m.
(Codomain (Folded f (Serialization pos s)) ~ Const m, Monoid m) =>
Folded f (Serialization pos s)
-> Domain
     (Folded f (Serialization pos s))
     (g (Domain (Folded f (Serialization pos s)))
        (Domain (Folded f (Serialization pos s))))
-> m
foldMap = Folded f (Serialization pos s)
-> Domain
     (Folded f (Serialization pos s))
     (g (Domain (Folded f (Serialization pos s)))
        (Domain (Folded f (Serialization pos s))))
-> m
forall t (g :: (* -> *) -> (* -> *) -> *) m.
(At t (g (Domain t) (Domain t)), Foldable t g,
 Codomain t ~ Const m, Foldable (Domain t), Monoid m) =>
t -> Domain t (g (Domain t) (Domain t)) -> m
Full.foldMapDownDefault