    {-# language BangPatterns          #-}
    {-# language CPP                   #-}
    {-# language DeriveDataTypeable    #-}
    {-# language DeriveGeneric         #-}
    {-# language FlexibleInstances     #-}
    {-# language MultiParamTypeClasses #-}
    {-# language TypeFamilies          #-}
    -----------------------------------------------------------------------------
    -- |
    -- Copyright   :  (C) 2011-2019 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  experimental
    -- Portability :  non-portable
    --
    -- A rope is a data strucure to efficiently store and manipulate long strings.
    -- Wikipedia provides a nice overview:
    -- <https://en.wikipedia.org/wiki/Rope_(data_structure)>
    ----------------------------------------------------------------------------
    module Text.Trifecta.Rope
      ( Rope(..)
      , rope
      , ropeBS
      , Strand(..)
      , strand
      , strands
      , grabRest
      , grabLine
      ) where

    import           Data.ByteString        (ByteString)
    import qualified Data.ByteString        as Strict
    import qualified Data.ByteString.Lazy   as Lazy
    import qualified Data.ByteString.UTF8   as UTF8
    import           Data.Data
    import           Data.FingerTree        as FingerTree
    import           Data.Foldable          (toList)
    import           Data.Hashable
    #if !(MIN_VERSION_base(4,11,0))
    import           Data.Semigroup
    #endif
    import           Data.Semigroup.Reducer
    import           GHC.Generics

    import Text.Trifecta.Delta
    import Text.Trifecta.Util.Combinators as Util

    -- $setup
    --
    -- >>> :set -XOverloadedStrings
    -- >>> import Data.Monoid ((<>))
    -- >>> import Data.ByteString (ByteString)
    -- >>> import qualified Data.ByteString.UTF8 as Strict
    -- >>> import qualified Data.ByteString.Lazy.UTF8 as Lazy
    -- >>> import Text.Trifecta.Delta

    -- A 'Strand' is a chunk of data; many 'Strand's together make a 'Rope'.
    data Strand
      = Strand {-# UNPACK #-} !ByteString !Delta -- ^ Data of a certain length
      | Skipping !Delta                          -- ^ Absence of data of a certain length
      deriving (Strand -> Strand -> Bool
    (Strand -> Strand -> Bool)
    -> (Strand -> Strand -> Bool) -> Eq Strand
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Strand -> Strand -> Bool
    == :: Strand -> Strand -> Bool
    $c/= :: Strand -> Strand -> Bool
    /= :: Strand -> Strand -> Bool
    Eq, Int -> Strand -> ShowS
    [Strand] -> ShowS
    Strand -> String
    (Int -> Strand -> ShowS)
    -> (Strand -> String) -> ([Strand] -> ShowS) -> Show Strand
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Strand -> ShowS
    showsPrec :: Int -> Strand -> ShowS
    $cshow :: Strand -> String
    show :: Strand -> String
    $cshowList :: [Strand] -> ShowS
    showList :: [Strand] -> ShowS
    Show, Typeable Strand
    Typeable Strand =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Strand -> c Strand)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Strand)
    -> (Strand -> Constr)
    -> (Strand -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Strand))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand))
    -> ((forall b. Data b => b -> b) -> Strand -> Strand)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Strand -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Strand -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Strand -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Strand -> m Strand)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Strand -> m Strand)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Strand -> m Strand)
    -> Data Strand
    Strand -> Constr
    Strand -> DataType
    (forall b. Data b => b -> b) -> Strand -> Strand
    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) -> Strand -> u
    forall u. (forall d. Data d => d -> u) -> Strand -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Strand
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Strand -> c Strand
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Strand)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Strand -> c Strand
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Strand -> c Strand
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Strand
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Strand
    $ctoConstr :: Strand -> Constr
    toConstr :: Strand -> Constr
    $cdataTypeOf :: Strand -> DataType
    dataTypeOf :: Strand -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Strand)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Strand)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strand)
    $cgmapT :: (forall b. Data b => b -> b) -> Strand -> Strand
    gmapT :: (forall b. Data b => b -> b) -> Strand -> Strand
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strand -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Strand -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Strand -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Strand -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Strand -> m Strand
    Data, (forall x. Strand -> Rep Strand x)
    -> (forall x. Rep Strand x -> Strand) -> Generic Strand
    forall x. Rep Strand x -> Strand
    forall x. Strand -> Rep Strand x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Strand -> Rep Strand x
    from :: forall x. Strand -> Rep Strand x
    $cto :: forall x. Rep Strand x -> Strand
    to :: forall x. Rep Strand x -> Strand
    Generic)

    -- | Construct a single 'Strand' out of a 'ByteString'.
    strand :: ByteString -> Strand
    strand :: ByteString -> Strand
    strand ByteString
    bs = ByteString -> Delta -> Strand
    Strand ByteString
    bs (ByteString -> Delta
    forall t. HasDelta t => t -> Delta
    delta ByteString
    bs)

    instance Measured Delta Strand where
      measure :: Strand -> Delta
    measure (Strand ByteString
    _ Delta
    s) = Delta -> Delta
    forall t. HasDelta t => t -> Delta
    delta Delta
    s
      measure (Skipping Delta
    d) = Delta
    d

    instance Hashable Strand

    instance HasDelta Strand where
      delta :: Strand -> Delta
    delta = Strand -> Delta
    forall v a. Measured v a => a -> v
    measure

    instance HasBytes Strand where
      bytes :: Strand -> Int64
    bytes (Strand ByteString
    _ Delta
    d) = Delta -> Int64
    forall t. HasBytes t => t -> Int64
    bytes Delta
    d
      bytes Strand
    _            = Int64
    0

    data Rope = Rope !Delta !(FingerTree Delta Strand) deriving Int -> Rope -> ShowS
    [Rope] -> ShowS
    Rope -> String
    (Int -> Rope -> ShowS)
    -> (Rope -> String) -> ([Rope] -> ShowS) -> Show Rope
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Rope -> ShowS
    showsPrec :: Int -> Rope -> ShowS
    $cshow :: Rope -> String
    show :: Rope -> String
    $cshowList :: [Rope] -> ShowS
    showList :: [Rope] -> ShowS
    Show

    rope :: FingerTree Delta Strand -> Rope
    rope :: FingerTree Delta Strand -> Rope
    rope FingerTree Delta Strand
    r = Delta -> FingerTree Delta Strand -> Rope
    Rope (FingerTree Delta Strand -> Delta
    forall v a. Measured v a => a -> v
    measure FingerTree Delta Strand
    r) FingerTree Delta Strand
    r

    -- | Construct a 'Rope' out of a single 'ByteString' strand.
    ropeBS :: ByteString -> Rope
    ropeBS :: ByteString -> Rope
    ropeBS = FingerTree Delta Strand -> Rope
    rope (FingerTree Delta Strand -> Rope)
    -> (ByteString -> FingerTree Delta Strand) -> ByteString -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Strand -> FingerTree Delta Strand
    forall v a. Measured v a => a -> FingerTree v a
    singleton (Strand -> FingerTree Delta Strand)
    -> (ByteString -> Strand) -> ByteString -> FingerTree Delta Strand
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand

    strands :: Rope -> FingerTree Delta Strand
    strands :: Rope -> FingerTree Delta Strand
    strands (Rope Delta
    _ FingerTree Delta Strand
    r) = FingerTree Delta Strand
    r

    -- | Grab the entire rest of the input 'Rope', starting at an initial offset, or
    -- return a default if we’re already at or beyond the end. Also see 'grabLine'.
    --
    -- Extract a suffix of a certain length from the input:
    --
    -- >>> grabRest (delta ("Hello " :: ByteString)) (ropeBS "Hello World\nLorem") Nothing (\x y -> Just (x, Lazy.toString y))
    -- Just (Columns 6 6,"World\nLorem")
    --
    -- Same deal, but over multiple strands:
    --
    -- >>> grabRest (delta ("Hel" :: ByteString)) (ropeBS "Hello" <> ropeBS "World") Nothing (\x y -> Just (x, Lazy.toString y))
    -- Just (Columns 3 3,"loWorld")
    --
    -- When the offset is too long, fall back to a default:
    --
    -- >>> grabRest (delta ("OffetTooLong" :: ByteString)) (ropeBS "Hello") Nothing (\x y -> Just (x, Lazy.toString y))
    -- Nothing
    grabRest
        :: Delta -- ^ Initial offset
        -> Rope  -- ^ Input
        -> r     -- ^ Default value if there is no input left
        -> (Delta -> Lazy.ByteString -> r)
            -- ^ If there is some input left, create an @r@ out of the data from the
            -- initial offset until the end
        -> r
    grabRest :: forall r. Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r
    grabRest Delta
    offset Rope
    input r
    failure Delta -> ByteString -> r
    success = Delta -> Int64 -> [Strand] -> r
    trim (FingerTree Delta Strand -> Delta
    forall t. HasDelta t => t -> Delta
    delta FingerTree Delta Strand
    l) (Delta -> Int64
    forall t. HasBytes t => t -> Int64
    bytes Delta
    offset Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    - FingerTree Delta Strand -> Int64
    forall t. HasBytes t => t -> Int64
    bytes FingerTree Delta Strand
    l) (FingerTree Delta Strand -> [Strand]
    forall a. FingerTree Delta a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList FingerTree Delta Strand
    r) where
      trim :: Delta -> Int64 -> [Strand] -> r
    trim Delta
    offset' Int64
    0 (Strand ByteString
    str Delta
    _ : [Strand]
    xs) = Delta -> ByteString -> [Strand] -> r
    go Delta
    offset' ByteString
    str [Strand]
    xs
      trim Delta
    _       Int64
    k (Strand ByteString
    str Delta
    _ : [Strand]
    xs) = Delta -> ByteString -> [Strand] -> r
    go Delta
    offset (Int -> ByteString -> ByteString
    Strict.drop (Int64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int64
    k) ByteString
    str) [Strand]
    xs
      trim Delta
    offset' Int64
    k (Skipping Delta
    p   : [Strand]
    xs) = Delta -> Int64 -> [Strand] -> r
    trim (Delta
    offset' Delta -> Delta -> Delta
    forall a. Semigroup a => a -> a -> a
    <> Delta
    p) Int64
    k [Strand]
    xs
      trim Delta
    _       Int64
    _ []                  = r
    failure

      go :: Delta -> ByteString -> [Strand] -> r
    go Delta
    offset' ByteString
    str [Strand]
    strands'
        = Delta -> ByteString -> r
    success Delta
    offset' ([ByteString] -> ByteString
    Lazy.fromChunks (ByteString
    str ByteString -> [ByteString] -> [ByteString]
    forall a. a -> [a] -> [a]
    : [ ByteString
    a | Strand ByteString
    a Delta
    _ <- [Strand]
    strands' ]))

      (FingerTree Delta Strand
    l, FingerTree Delta Strand
    r) = Delta -> Rope -> (FingerTree Delta Strand, FingerTree Delta Strand)
    splitRopeAt Delta
    offset Rope
    input

    -- | Split the rope in two halves, given a 'Delta' offset from the beginning.
    splitRopeAt :: Delta -> Rope -> (FingerTree Delta Strand, FingerTree Delta Strand)
    splitRopeAt :: Delta -> Rope -> (FingerTree Delta Strand, FingerTree Delta Strand)
    splitRopeAt Delta
    splitPos = (Delta -> Bool)
    -> FingerTree Delta Strand
    -> (FingerTree Delta Strand, FingerTree Delta Strand)
    forall v a.
    Measured v a =>
    (v -> Bool) -> FingerTree v a -> (FingerTree v a, FingerTree v a)
    FingerTree.split (\Delta
    pos -> Delta -> Int64
    forall t. HasBytes t => t -> Int64
    bytes Delta
    pos Int64 -> Int64 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Delta -> Int64
    forall t. HasBytes t => t -> Int64
    bytes Delta
    splitPos) (FingerTree Delta Strand
     -> (FingerTree Delta Strand, FingerTree Delta Strand))
    -> (Rope -> FingerTree Delta Strand)
    -> Rope
    -> (FingerTree Delta Strand, FingerTree Delta Strand)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rope -> FingerTree Delta Strand
    strands

    -- | Grab the rest of the line at a certain offset in the input 'Rope', or
    -- return a default if there is no newline left in the input. Also see
    -- 'grabRest'.
    --
    -- >>> grabLine (delta ("Hello " :: ByteString)) (ropeBS "Hello" <> ropeBS " World\nLorem") Nothing (\x y -> Just (x, Strict.toString y))
    -- Just (Columns 6 6,"World\n")
    grabLine
        :: Delta -- ^ Initial offset
        -> Rope  -- ^ Input
        -> r     -- ^ Default value if there is no input left
        -> (Delta -> Strict.ByteString -> r)
            -- ^ If there is some input left, create an @r@ out of the data from the
            -- initial offset until the end of the line
        -> r
    grabLine :: forall r. Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r
    grabLine Delta
    offset Rope
    input r
    failure Delta -> ByteString -> r
    success
      = Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r
    forall r. Delta -> Rope -> r -> (Delta -> ByteString -> r) -> r
    grabRest Delta
    offset Rope
    input r
    failure (\Delta
    d -> Delta -> ByteString -> r
    success Delta
    d (ByteString -> r) -> (ByteString -> ByteString) -> ByteString -> r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteString
    Util.fromLazy (ByteString -> ByteString)
    -> (ByteString -> ByteString) -> ByteString -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteString
    Util.takeLine)

    instance HasBytes Rope where
      bytes :: Rope -> Int64
    bytes = Delta -> Int64
    forall t. HasBytes t => t -> Int64
    bytes (Delta -> Int64) -> (Rope -> Delta) -> Rope -> Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rope -> Delta
    forall v a. Measured v a => a -> v
    measure

    instance HasDelta Rope where
      delta :: Rope -> Delta
    delta = Rope -> Delta
    forall v a. Measured v a => a -> v
    measure

    instance Measured Delta Rope where
      measure :: Rope -> Delta
    measure (Rope Delta
    s FingerTree Delta Strand
    _) = Delta
    s

    instance Monoid Rope where
      mempty :: Rope
    mempty = Delta -> FingerTree Delta Strand -> Rope
    Rope Delta
    forall a. Monoid a => a
    mempty FingerTree Delta Strand
    forall a. Monoid a => a
    mempty
      mappend :: Rope -> Rope -> Rope
    mappend = Rope -> Rope -> Rope
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Semigroup Rope where
      Rope Delta
    mx FingerTree Delta Strand
    x <> :: Rope -> Rope -> Rope
    <> Rope Delta
    my FingerTree Delta Strand
    y = Delta -> FingerTree Delta Strand -> Rope
    Rope (Delta
    mx Delta -> Delta -> Delta
    forall a. Semigroup a => a -> a -> a
    <> Delta
    my) (FingerTree Delta Strand
    x FingerTree Delta Strand
    -> FingerTree Delta Strand -> FingerTree Delta Strand
    forall a. Monoid a => a -> a -> a
    `mappend` FingerTree Delta Strand
    y)

    instance Reducer Rope Rope where
      unit :: Rope -> Rope
    unit = Rope -> Rope
    forall a. a -> a
    id

    instance Reducer Strand Rope where
      unit :: Strand -> Rope
    unit Strand
    s = FingerTree Delta Strand -> Rope
    rope (Strand -> FingerTree Delta Strand
    forall v a. Measured v a => a -> FingerTree v a
    FingerTree.singleton Strand
    s)
      cons :: Strand -> Rope -> Rope
    cons Strand
    s (Rope Delta
    mt FingerTree Delta Strand
    t) = Delta -> FingerTree Delta Strand -> Rope
    Rope (Strand -> Delta
    forall t. HasDelta t => t -> Delta
    delta Strand
    s Delta -> Delta -> Delta
    forall a. Monoid a => a -> a -> a
    `mappend` Delta
    mt) (Strand
    s Strand -> FingerTree Delta Strand -> FingerTree Delta Strand
    forall v a. Measured v a => a -> FingerTree v a -> FingerTree v a
    <| FingerTree Delta Strand
    t)
      snoc :: Rope -> Strand -> Rope
    snoc (Rope Delta
    mt FingerTree Delta Strand
    t) !Strand
    s = Delta -> FingerTree Delta Strand -> Rope
    Rope (Delta
    mt Delta -> Delta -> Delta
    forall a. Monoid a => a -> a -> a
    `mappend` Strand -> Delta
    forall t. HasDelta t => t -> Delta
    delta Strand
    s) (FingerTree Delta Strand
    t FingerTree Delta Strand -> Strand -> FingerTree Delta Strand
    forall v a. Measured v a => FingerTree v a -> a -> FingerTree v a
    |> Strand
    s)

    instance Reducer Strict.ByteString Rope where
      unit :: ByteString -> Rope
    unit = Strand -> Rope
    forall c m. Reducer c m => c -> m
    unit (Strand -> Rope) -> (ByteString -> Strand) -> ByteString -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand
      cons :: ByteString -> Rope -> Rope
    cons = Strand -> Rope -> Rope
    forall c m. Reducer c m => c -> m -> m
    cons (Strand -> Rope -> Rope)
    -> (ByteString -> Strand) -> ByteString -> Rope -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand
      snoc :: Rope -> ByteString -> Rope
    snoc Rope
    r = Rope -> Strand -> Rope
    forall c m. Reducer c m => m -> c -> m
    snoc Rope
    r (Strand -> Rope) -> (ByteString -> Strand) -> ByteString -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand

    instance Reducer [Char] Rope where
      unit :: String -> Rope
    unit = Strand -> Rope
    forall c m. Reducer c m => c -> m
    unit (Strand -> Rope) -> (String -> Strand) -> String -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand (ByteString -> Strand)
    -> (String -> ByteString) -> String -> Strand
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ByteString
    UTF8.fromString
      cons :: String -> Rope -> Rope
    cons = Strand -> Rope -> Rope
    forall c m. Reducer c m => c -> m -> m
    cons (Strand -> Rope -> Rope)
    -> (String -> Strand) -> String -> Rope -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand (ByteString -> Strand)
    -> (String -> ByteString) -> String -> Strand
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ByteString
    UTF8.fromString
      snoc :: Rope -> String -> Rope
    snoc Rope
    r = Rope -> Strand -> Rope
    forall c m. Reducer c m => m -> c -> m
    snoc Rope
    r (Strand -> Rope) -> (String -> Strand) -> String -> Rope
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Strand
    strand (ByteString -> Strand)
    -> (String -> ByteString) -> String -> Strand
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ByteString
    UTF8.fromString