{-# LANGUAGE DataKinds, TypeFamilies, UndecidableInstances #-}

module BytePatch.Core where

import GHC.Generics ( Generic )
import GHC.Natural

data Patch (s :: SeekKind) a = Patch (SeekRep s) (Edit a)
    deriving ((forall x. Patch s a -> Rep (Patch s a) x)
-> (forall x. Rep (Patch s a) x -> Patch s a)
-> Generic (Patch s a)
forall x. Rep (Patch s a) x -> Patch s a
forall x. Patch s a -> Rep (Patch s a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (s :: SeekKind) a x. Rep (Patch s a) x -> Patch s a
forall (s :: SeekKind) a x. Patch s a -> Rep (Patch s a) x
$cto :: forall (s :: SeekKind) a x. Rep (Patch s a) x -> Patch s a
$cfrom :: forall (s :: SeekKind) a x. Patch s a -> Rep (Patch s a) x
Generic, (forall a b. (a -> b) -> Patch s a -> Patch s b)
-> (forall a b. a -> Patch s b -> Patch s a) -> Functor (Patch s)
forall a b. a -> Patch s b -> Patch s a
forall a b. (a -> b) -> Patch s a -> Patch s b
forall (s :: SeekKind) a b. a -> Patch s b -> Patch s a
forall (s :: SeekKind) a b. (a -> b) -> Patch s a -> Patch s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Patch s b -> Patch s a
$c<$ :: forall (s :: SeekKind) a b. a -> Patch s b -> Patch s a
fmap :: forall a b. (a -> b) -> Patch s a -> Patch s b
$cfmap :: forall (s :: SeekKind) a b. (a -> b) -> Patch s a -> Patch s b
Functor, (forall m. Monoid m => Patch s m -> m)
-> (forall m a. Monoid m => (a -> m) -> Patch s a -> m)
-> (forall m a. Monoid m => (a -> m) -> Patch s a -> m)
-> (forall a b. (a -> b -> b) -> b -> Patch s a -> b)
-> (forall a b. (a -> b -> b) -> b -> Patch s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Patch s a -> b)
-> (forall b a. (b -> a -> b) -> b -> Patch s a -> b)
-> (forall a. (a -> a -> a) -> Patch s a -> a)
-> (forall a. (a -> a -> a) -> Patch s a -> a)
-> (forall a. Patch s a -> [a])
-> (forall a. Patch s a -> Bool)
-> (forall a. Patch s a -> Int)
-> (forall a. Eq a => a -> Patch s a -> Bool)
-> (forall a. Ord a => Patch s a -> a)
-> (forall a. Ord a => Patch s a -> a)
-> (forall a. Num a => Patch s a -> a)
-> (forall a. Num a => Patch s a -> a)
-> Foldable (Patch s)
forall a. Eq a => a -> Patch s a -> Bool
forall a. Num a => Patch s a -> a
forall a. Ord a => Patch s a -> a
forall m. Monoid m => Patch s m -> m
forall a. Patch s a -> Bool
forall a. Patch s a -> Int
forall a. Patch s a -> [a]
forall a. (a -> a -> a) -> Patch s a -> a
forall m a. Monoid m => (a -> m) -> Patch s a -> m
forall b a. (b -> a -> b) -> b -> Patch s a -> b
forall a b. (a -> b -> b) -> b -> Patch s a -> b
forall (s :: SeekKind) a. Eq a => a -> Patch s a -> Bool
forall (s :: SeekKind) a. Num a => Patch s a -> a
forall (s :: SeekKind) a. Ord a => Patch s a -> a
forall (s :: SeekKind) m. Monoid m => Patch s m -> m
forall (s :: SeekKind) a. Patch s a -> Bool
forall (s :: SeekKind) a. Patch s a -> Int
forall (s :: SeekKind) a. Patch s a -> [a]
forall (s :: SeekKind) a. (a -> a -> a) -> Patch s a -> a
forall (s :: SeekKind) m a. Monoid m => (a -> m) -> Patch s a -> m
forall (s :: SeekKind) b a. (b -> a -> b) -> b -> Patch s a -> b
forall (s :: SeekKind) a b. (a -> b -> b) -> b -> Patch s a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Patch s a -> a
$cproduct :: forall (s :: SeekKind) a. Num a => Patch s a -> a
sum :: forall a. Num a => Patch s a -> a
$csum :: forall (s :: SeekKind) a. Num a => Patch s a -> a
minimum :: forall a. Ord a => Patch s a -> a
$cminimum :: forall (s :: SeekKind) a. Ord a => Patch s a -> a
maximum :: forall a. Ord a => Patch s a -> a
$cmaximum :: forall (s :: SeekKind) a. Ord a => Patch s a -> a
elem :: forall a. Eq a => a -> Patch s a -> Bool
$celem :: forall (s :: SeekKind) a. Eq a => a -> Patch s a -> Bool
length :: forall a. Patch s a -> Int
$clength :: forall (s :: SeekKind) a. Patch s a -> Int
null :: forall a. Patch s a -> Bool
$cnull :: forall (s :: SeekKind) a. Patch s a -> Bool
toList :: forall a. Patch s a -> [a]
$ctoList :: forall (s :: SeekKind) a. Patch s a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Patch s a -> a
$cfoldl1 :: forall (s :: SeekKind) a. (a -> a -> a) -> Patch s a -> a
foldr1 :: forall a. (a -> a -> a) -> Patch s a -> a
$cfoldr1 :: forall (s :: SeekKind) a. (a -> a -> a) -> Patch s a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Patch s a -> b
$cfoldl' :: forall (s :: SeekKind) b a. (b -> a -> b) -> b -> Patch s a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Patch s a -> b
$cfoldl :: forall (s :: SeekKind) b a. (b -> a -> b) -> b -> Patch s a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Patch s a -> b
$cfoldr' :: forall (s :: SeekKind) a b. (a -> b -> b) -> b -> Patch s a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Patch s a -> b
$cfoldr :: forall (s :: SeekKind) a b. (a -> b -> b) -> b -> Patch s a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Patch s a -> m
$cfoldMap' :: forall (s :: SeekKind) m a. Monoid m => (a -> m) -> Patch s a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Patch s a -> m
$cfoldMap :: forall (s :: SeekKind) m a. Monoid m => (a -> m) -> Patch s a -> m
fold :: forall m. Monoid m => Patch s m -> m
$cfold :: forall (s :: SeekKind) m. Monoid m => Patch s m -> m
Foldable, Functor (Patch s)
Foldable (Patch s)
Functor (Patch s)
-> Foldable (Patch s)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Patch s a -> f (Patch s b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Patch s (f a) -> f (Patch s a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Patch s a -> m (Patch s b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Patch s (m a) -> m (Patch s a))
-> Traversable (Patch s)
forall (s :: SeekKind). Functor (Patch s)
forall (s :: SeekKind). Foldable (Patch s)
forall (s :: SeekKind) (m :: * -> *) a.
Monad m =>
Patch s (m a) -> m (Patch s a)
forall (s :: SeekKind) (f :: * -> *) a.
Applicative f =>
Patch s (f a) -> f (Patch s a)
forall (s :: SeekKind) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Patch s a -> m (Patch s b)
forall (s :: SeekKind) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Patch s a -> f (Patch s b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Patch s (m a) -> m (Patch s a)
forall (f :: * -> *) a.
Applicative f =>
Patch s (f a) -> f (Patch s a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Patch s a -> m (Patch s b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Patch s a -> f (Patch s b)
sequence :: forall (m :: * -> *) a. Monad m => Patch s (m a) -> m (Patch s a)
$csequence :: forall (s :: SeekKind) (m :: * -> *) a.
Monad m =>
Patch s (m a) -> m (Patch s a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Patch s a -> m (Patch s b)
$cmapM :: forall (s :: SeekKind) (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Patch s a -> m (Patch s b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Patch s (f a) -> f (Patch s a)
$csequenceA :: forall (s :: SeekKind) (f :: * -> *) a.
Applicative f =>
Patch s (f a) -> f (Patch s a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Patch s a -> f (Patch s b)
$ctraverse :: forall (s :: SeekKind) (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Patch s a -> f (Patch s b)
Traversable)

deriving instance (Eq (SeekRep s), Eq a) => Eq (Patch s a)
deriving instance (Show (SeekRep s), Show a) => Show (Patch s a)

data SeekKind
  = FwdSeek    -- ^ seeks only move cursor forward
  | CursorSeek -- ^ seeks move cursor forward or backward
  | AbsSeek    -- ^ seeks specify an exact offset in stream
    deriving (SeekKind -> SeekKind -> Bool
(SeekKind -> SeekKind -> Bool)
-> (SeekKind -> SeekKind -> Bool) -> Eq SeekKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SeekKind -> SeekKind -> Bool
$c/= :: SeekKind -> SeekKind -> Bool
== :: SeekKind -> SeekKind -> Bool
$c== :: SeekKind -> SeekKind -> Bool
Eq, Int -> SeekKind -> ShowS
[SeekKind] -> ShowS
SeekKind -> String
(Int -> SeekKind -> ShowS)
-> (SeekKind -> String) -> ([SeekKind] -> ShowS) -> Show SeekKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SeekKind] -> ShowS
$cshowList :: [SeekKind] -> ShowS
show :: SeekKind -> String
$cshow :: SeekKind -> String
showsPrec :: Int -> SeekKind -> ShowS
$cshowsPrec :: Int -> SeekKind -> ShowS
Show, (forall x. SeekKind -> Rep SeekKind x)
-> (forall x. Rep SeekKind x -> SeekKind) -> Generic SeekKind
forall x. Rep SeekKind x -> SeekKind
forall x. SeekKind -> Rep SeekKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SeekKind x -> SeekKind
$cfrom :: forall x. SeekKind -> Rep SeekKind x
Generic)

type family SeekRep (s :: SeekKind) where
    SeekRep 'FwdSeek    = Natural
    SeekRep 'CursorSeek = Integer
    SeekRep 'AbsSeek    = Natural

-- | Data to add to a stream.
data Edit a = Edit
  { forall a. Edit a -> a
editData :: a
  , forall a. Edit a -> EditMeta a
editMeta :: EditMeta a
  } deriving (Edit a -> Edit a -> Bool
(Edit a -> Edit a -> Bool)
-> (Edit a -> Edit a -> Bool) -> Eq (Edit a)
forall a. Eq a => Edit a -> Edit a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Edit a -> Edit a -> Bool
$c/= :: forall a. Eq a => Edit a -> Edit a -> Bool
== :: Edit a -> Edit a -> Bool
$c== :: forall a. Eq a => Edit a -> Edit a -> Bool
Eq, Int -> Edit a -> ShowS
[Edit a] -> ShowS
Edit a -> String
(Int -> Edit a -> ShowS)
-> (Edit a -> String) -> ([Edit a] -> ShowS) -> Show (Edit a)
forall a. Show a => Int -> Edit a -> ShowS
forall a. Show a => [Edit a] -> ShowS
forall a. Show a => Edit a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Edit a] -> ShowS
$cshowList :: forall a. Show a => [Edit a] -> ShowS
show :: Edit a -> String
$cshow :: forall a. Show a => Edit a -> String
showsPrec :: Int -> Edit a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Edit a -> ShowS
Show, (forall x. Edit a -> Rep (Edit a) x)
-> (forall x. Rep (Edit a) x -> Edit a) -> Generic (Edit a)
forall x. Rep (Edit a) x -> Edit a
forall x. Edit a -> Rep (Edit a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Edit a) x -> Edit a
forall a x. Edit a -> Rep (Edit a) x
$cto :: forall a x. Rep (Edit a) x -> Edit a
$cfrom :: forall a x. Edit a -> Rep (Edit a) x
Generic, (forall a b. (a -> b) -> Edit a -> Edit b)
-> (forall a b. a -> Edit b -> Edit a) -> Functor Edit
forall a b. a -> Edit b -> Edit a
forall a b. (a -> b) -> Edit a -> Edit b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Edit b -> Edit a
$c<$ :: forall a b. a -> Edit b -> Edit a
fmap :: forall a b. (a -> b) -> Edit a -> Edit b
$cfmap :: forall a b. (a -> b) -> Edit a -> Edit b
Functor, (forall m. Monoid m => Edit m -> m)
-> (forall m a. Monoid m => (a -> m) -> Edit a -> m)
-> (forall m a. Monoid m => (a -> m) -> Edit a -> m)
-> (forall a b. (a -> b -> b) -> b -> Edit a -> b)
-> (forall a b. (a -> b -> b) -> b -> Edit a -> b)
-> (forall b a. (b -> a -> b) -> b -> Edit a -> b)
-> (forall b a. (b -> a -> b) -> b -> Edit a -> b)
-> (forall a. (a -> a -> a) -> Edit a -> a)
-> (forall a. (a -> a -> a) -> Edit a -> a)
-> (forall a. Edit a -> [a])
-> (forall a. Edit a -> Bool)
-> (forall a. Edit a -> Int)
-> (forall a. Eq a => a -> Edit a -> Bool)
-> (forall a. Ord a => Edit a -> a)
-> (forall a. Ord a => Edit a -> a)
-> (forall a. Num a => Edit a -> a)
-> (forall a. Num a => Edit a -> a)
-> Foldable Edit
forall a. Eq a => a -> Edit a -> Bool
forall a. Num a => Edit a -> a
forall a. Ord a => Edit a -> a
forall m. Monoid m => Edit m -> m
forall a. Edit a -> Bool
forall a. Edit a -> Int
forall a. Edit a -> [a]
forall a. (a -> a -> a) -> Edit a -> a
forall m a. Monoid m => (a -> m) -> Edit a -> m
forall b a. (b -> a -> b) -> b -> Edit a -> b
forall a b. (a -> b -> b) -> b -> Edit a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Edit a -> a
$cproduct :: forall a. Num a => Edit a -> a
sum :: forall a. Num a => Edit a -> a
$csum :: forall a. Num a => Edit a -> a
minimum :: forall a. Ord a => Edit a -> a
$cminimum :: forall a. Ord a => Edit a -> a
maximum :: forall a. Ord a => Edit a -> a
$cmaximum :: forall a. Ord a => Edit a -> a
elem :: forall a. Eq a => a -> Edit a -> Bool
$celem :: forall a. Eq a => a -> Edit a -> Bool
length :: forall a. Edit a -> Int
$clength :: forall a. Edit a -> Int
null :: forall a. Edit a -> Bool
$cnull :: forall a. Edit a -> Bool
toList :: forall a. Edit a -> [a]
$ctoList :: forall a. Edit a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Edit a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Edit a -> a
foldr1 :: forall a. (a -> a -> a) -> Edit a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Edit a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Edit a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Edit a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Edit a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Edit a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Edit a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Edit a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Edit a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Edit a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Edit a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Edit a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Edit a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Edit a -> m
fold :: forall m. Monoid m => Edit m -> m
$cfold :: forall m. Monoid m => Edit m -> m
Foldable, Functor Edit
Foldable Edit
Functor Edit
-> Foldable Edit
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Edit a -> f (Edit b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Edit (f a) -> f (Edit a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Edit a -> m (Edit b))
-> (forall (m :: * -> *) a. Monad m => Edit (m a) -> m (Edit a))
-> Traversable Edit
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Edit (m a) -> m (Edit a)
forall (f :: * -> *) a. Applicative f => Edit (f a) -> f (Edit a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Edit a -> m (Edit b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Edit a -> f (Edit b)
sequence :: forall (m :: * -> *) a. Monad m => Edit (m a) -> m (Edit a)
$csequence :: forall (m :: * -> *) a. Monad m => Edit (m a) -> m (Edit a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Edit a -> m (Edit b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Edit a -> m (Edit b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Edit (f a) -> f (Edit a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Edit (f a) -> f (Edit a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Edit a -> f (Edit b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Edit a -> f (Edit b)
Traversable)

-- | Various optional metadata defining expected existing data for an 'Edit'.
data EditMeta a = EditMeta
  { forall a. EditMeta a -> Maybe Int
emNullTerminates :: Maybe Int
  -- ^ Stream segment should be null bytes (0x00) only from this index onwards.

  , forall a. EditMeta a -> Maybe a
emExpected       :: Maybe a
  -- ^ Stream segment should be this.
  } deriving (EditMeta a -> EditMeta a -> Bool
(EditMeta a -> EditMeta a -> Bool)
-> (EditMeta a -> EditMeta a -> Bool) -> Eq (EditMeta a)
forall a. Eq a => EditMeta a -> EditMeta a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EditMeta a -> EditMeta a -> Bool
$c/= :: forall a. Eq a => EditMeta a -> EditMeta a -> Bool
== :: EditMeta a -> EditMeta a -> Bool
$c== :: forall a. Eq a => EditMeta a -> EditMeta a -> Bool
Eq, Int -> EditMeta a -> ShowS
[EditMeta a] -> ShowS
EditMeta a -> String
(Int -> EditMeta a -> ShowS)
-> (EditMeta a -> String)
-> ([EditMeta a] -> ShowS)
-> Show (EditMeta a)
forall a. Show a => Int -> EditMeta a -> ShowS
forall a. Show a => [EditMeta a] -> ShowS
forall a. Show a => EditMeta a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EditMeta a] -> ShowS
$cshowList :: forall a. Show a => [EditMeta a] -> ShowS
show :: EditMeta a -> String
$cshow :: forall a. Show a => EditMeta a -> String
showsPrec :: Int -> EditMeta a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> EditMeta a -> ShowS
Show, (forall x. EditMeta a -> Rep (EditMeta a) x)
-> (forall x. Rep (EditMeta a) x -> EditMeta a)
-> Generic (EditMeta a)
forall x. Rep (EditMeta a) x -> EditMeta a
forall x. EditMeta a -> Rep (EditMeta a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (EditMeta a) x -> EditMeta a
forall a x. EditMeta a -> Rep (EditMeta a) x
$cto :: forall a x. Rep (EditMeta a) x -> EditMeta a
$cfrom :: forall a x. EditMeta a -> Rep (EditMeta a) x
Generic, (forall a b. (a -> b) -> EditMeta a -> EditMeta b)
-> (forall a b. a -> EditMeta b -> EditMeta a) -> Functor EditMeta
forall a b. a -> EditMeta b -> EditMeta a
forall a b. (a -> b) -> EditMeta a -> EditMeta b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> EditMeta b -> EditMeta a
$c<$ :: forall a b. a -> EditMeta b -> EditMeta a
fmap :: forall a b. (a -> b) -> EditMeta a -> EditMeta b
$cfmap :: forall a b. (a -> b) -> EditMeta a -> EditMeta b
Functor, (forall m. Monoid m => EditMeta m -> m)
-> (forall m a. Monoid m => (a -> m) -> EditMeta a -> m)
-> (forall m a. Monoid m => (a -> m) -> EditMeta a -> m)
-> (forall a b. (a -> b -> b) -> b -> EditMeta a -> b)
-> (forall a b. (a -> b -> b) -> b -> EditMeta a -> b)
-> (forall b a. (b -> a -> b) -> b -> EditMeta a -> b)
-> (forall b a. (b -> a -> b) -> b -> EditMeta a -> b)
-> (forall a. (a -> a -> a) -> EditMeta a -> a)
-> (forall a. (a -> a -> a) -> EditMeta a -> a)
-> (forall a. EditMeta a -> [a])
-> (forall a. EditMeta a -> Bool)
-> (forall a. EditMeta a -> Int)
-> (forall a. Eq a => a -> EditMeta a -> Bool)
-> (forall a. Ord a => EditMeta a -> a)
-> (forall a. Ord a => EditMeta a -> a)
-> (forall a. Num a => EditMeta a -> a)
-> (forall a. Num a => EditMeta a -> a)
-> Foldable EditMeta
forall a. Eq a => a -> EditMeta a -> Bool
forall a. Num a => EditMeta a -> a
forall a. Ord a => EditMeta a -> a
forall m. Monoid m => EditMeta m -> m
forall a. EditMeta a -> Bool
forall a. EditMeta a -> Int
forall a. EditMeta a -> [a]
forall a. (a -> a -> a) -> EditMeta a -> a
forall m a. Monoid m => (a -> m) -> EditMeta a -> m
forall b a. (b -> a -> b) -> b -> EditMeta a -> b
forall a b. (a -> b -> b) -> b -> EditMeta a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => EditMeta a -> a
$cproduct :: forall a. Num a => EditMeta a -> a
sum :: forall a. Num a => EditMeta a -> a
$csum :: forall a. Num a => EditMeta a -> a
minimum :: forall a. Ord a => EditMeta a -> a
$cminimum :: forall a. Ord a => EditMeta a -> a
maximum :: forall a. Ord a => EditMeta a -> a
$cmaximum :: forall a. Ord a => EditMeta a -> a
elem :: forall a. Eq a => a -> EditMeta a -> Bool
$celem :: forall a. Eq a => a -> EditMeta a -> Bool
length :: forall a. EditMeta a -> Int
$clength :: forall a. EditMeta a -> Int
null :: forall a. EditMeta a -> Bool
$cnull :: forall a. EditMeta a -> Bool
toList :: forall a. EditMeta a -> [a]
$ctoList :: forall a. EditMeta a -> [a]
foldl1 :: forall a. (a -> a -> a) -> EditMeta a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> EditMeta a -> a
foldr1 :: forall a. (a -> a -> a) -> EditMeta a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> EditMeta a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> EditMeta a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> EditMeta a -> b
foldl :: forall b a. (b -> a -> b) -> b -> EditMeta a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> EditMeta a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> EditMeta a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> EditMeta a -> b
foldr :: forall a b. (a -> b -> b) -> b -> EditMeta a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> EditMeta a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> EditMeta a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> EditMeta a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> EditMeta a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> EditMeta a -> m
fold :: forall m. Monoid m => EditMeta m -> m
$cfold :: forall m. Monoid m => EditMeta m -> m
Foldable, Functor EditMeta
Foldable EditMeta
Functor EditMeta
-> Foldable EditMeta
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> EditMeta a -> f (EditMeta b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    EditMeta (f a) -> f (EditMeta a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EditMeta a -> m (EditMeta b))
-> (forall (m :: * -> *) a.
    Monad m =>
    EditMeta (m a) -> m (EditMeta a))
-> Traversable EditMeta
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => EditMeta (m a) -> m (EditMeta a)
forall (f :: * -> *) a.
Applicative f =>
EditMeta (f a) -> f (EditMeta a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EditMeta a -> m (EditMeta b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EditMeta a -> f (EditMeta b)
sequence :: forall (m :: * -> *) a. Monad m => EditMeta (m a) -> m (EditMeta a)
$csequence :: forall (m :: * -> *) a. Monad m => EditMeta (m a) -> m (EditMeta a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EditMeta a -> m (EditMeta b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EditMeta a -> m (EditMeta b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
EditMeta (f a) -> f (EditMeta a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
EditMeta (f a) -> f (EditMeta a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EditMeta a -> f (EditMeta b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EditMeta a -> f (EditMeta b)
Traversable)