module ProAbstract.Structure.Inline
    ( Inline (..), Line (..), Lines (..), TaggedLines (..)
    ) where

import ProAbstract.Annotation
import ProAbstract.Content
import ProAbstract.Metadata
import ProAbstract.Structure.CanBePlain
import ProAbstract.Structure.CanFork
import ProAbstract.Structure.Fork
import ProAbstract.Structure.Fragment
import ProAbstract.Structure.HasManyPlainInlines
import ProAbstract.Structure.Plain
import ProAbstract.Tag


-- ⭐ Inline

data Inline ann =
    InlineFork (TaggedLines ann) -- ^ 'ProAbstract.fork'
  | InlinePlain (Fragment ann) -- ^ 'ProAbstract.plain'
  deriving stock (Inline ann -> Inline ann -> Bool
(Inline ann -> Inline ann -> Bool)
-> (Inline ann -> Inline ann -> Bool) -> Eq (Inline ann)
forall ann. Eq ann => Inline ann -> Inline ann -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inline ann -> Inline ann -> Bool
$c/= :: forall ann. Eq ann => Inline ann -> Inline ann -> Bool
== :: Inline ann -> Inline ann -> Bool
$c== :: forall ann. Eq ann => Inline ann -> Inline ann -> Bool
Eq, Int -> Inline ann -> ShowS
[Inline ann] -> ShowS
Inline ann -> String
(Int -> Inline ann -> ShowS)
-> (Inline ann -> String)
-> ([Inline ann] -> ShowS)
-> Show (Inline ann)
forall ann. Show ann => Int -> Inline ann -> ShowS
forall ann. Show ann => [Inline ann] -> ShowS
forall ann. Show ann => Inline ann -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Inline ann] -> ShowS
$cshowList :: forall ann. Show ann => [Inline ann] -> ShowS
show :: Inline ann -> String
$cshow :: forall ann. Show ann => Inline ann -> String
showsPrec :: Int -> Inline ann -> ShowS
$cshowsPrec :: forall ann. Show ann => Int -> Inline ann -> ShowS
Show, (forall x. Inline ann -> Rep (Inline ann) x)
-> (forall x. Rep (Inline ann) x -> Inline ann)
-> Generic (Inline ann)
forall x. Rep (Inline ann) x -> Inline ann
forall x. Inline ann -> Rep (Inline ann) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ann x. Rep (Inline ann) x -> Inline ann
forall ann x. Inline ann -> Rep (Inline ann) x
$cto :: forall ann x. Rep (Inline ann) x -> Inline ann
$cfrom :: forall ann x. Inline ann -> Rep (Inline ann) x
Generic)
  deriving anyclass (Eq (Inline ann)
Eq (Inline ann)
-> (Int -> Inline ann -> Int)
-> (Inline ann -> Int)
-> Hashable (Inline ann)
Int -> Inline ann -> Int
Inline ann -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ann. Hashable ann => Eq (Inline ann)
forall ann. Hashable ann => Int -> Inline ann -> Int
forall ann. Hashable ann => Inline ann -> Int
hash :: Inline ann -> Int
$chash :: forall ann. Hashable ann => Inline ann -> Int
hashWithSalt :: Int -> Inline ann -> Int
$chashWithSalt :: forall ann. Hashable ann => Int -> Inline ann -> Int
$cp1Hashable :: forall ann. Hashable ann => Eq (Inline ann)
Hashable, Inline ann -> ()
(Inline ann -> ()) -> NFData (Inline ann)
forall ann. NFData ann => Inline ann -> ()
forall a. (a -> ()) -> NFData a
rnf :: Inline ann -> ()
$crnf :: forall ann. NFData ann => Inline ann -> ()
NFData)

type instance Annotation (Inline ann) = ann

type instance Fork (Inline ann) = TaggedLines ann

type instance Plain (Inline ann) = Fragment ann

instance HasMetadata (Inline ann) where
    type MetadataOpticKind (Inline ann) = An_AffineTraversal
    metadata :: Optic' (MetadataOpticKind (Inline ann)) NoIx (Inline ann) Metadata
metadata = Optic
  An_AffineTraversal
  NoIx
  (Inline ann)
  (Inline ann)
  (Tag ann)
  (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Optic
  An_AffineTraversal
  NoIx
  (Inline ann)
  (Inline ann)
  (Tag ann)
  (Tag ann)
-> Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
-> Optic
     An_AffineTraversal NoIx (Inline ann) (Inline ann) Metadata Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
forall x.
HasMetadata x =>
Optic' (MetadataOpticKind x) NoIx x Metadata
metadata

instance HasManyAnnotations (Inline ann) (Inline ann') where
    allAnnotations :: Traversal
  (Inline ann)
  (Inline ann')
  (Annotation (Inline ann))
  (Annotation (Inline ann'))
allAnnotations = TraversalVL (Inline ann) (Inline ann') ann ann'
-> Traversal (Inline ann) (Inline ann') ann ann'
forall s t a b. TraversalVL s t a b -> Traversal s t a b
traversalVL \ann -> f ann'
f -> \case
        InlinePlain x -> Fragment ann' -> Inline ann'
forall ann. Fragment ann -> Inline ann
InlinePlain (Fragment ann' -> Inline ann')
-> f (Fragment ann') -> f (Inline ann')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic A_Lens NoIx (Fragment ann) (Fragment ann') ann ann'
-> (ann -> f ann') -> Fragment ann -> f (Fragment ann')
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic A_Lens NoIx (Fragment ann) (Fragment ann') ann ann'
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation ann -> f ann'
f Fragment ann
x
        InlineFork  x -> TaggedLines ann' -> Inline ann'
forall ann. TaggedLines ann -> Inline ann
InlineFork  (TaggedLines ann' -> Inline ann')
-> f (TaggedLines ann') -> f (Inline ann')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic
  A_Traversal NoIx (TaggedLines ann) (TaggedLines ann') ann ann'
-> (ann -> f ann') -> TaggedLines ann -> f (TaggedLines ann')
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic
  A_Traversal NoIx (TaggedLines ann) (TaggedLines ann') ann ann'
forall x x'.
HasManyAnnotations x x' =>
Traversal x x' (Annotation x) (Annotation x')
allAnnotations ann -> f ann'
f TaggedLines ann
x

instance HasAnnotation (Inline ann) (Inline ann) where
    annotation :: Lens
  (Inline ann)
  (Inline ann)
  (Annotation (Inline ann))
  (Annotation (Inline ann))
annotation = (Inline ann -> ann)
-> (Inline ann -> ann -> Inline ann)
-> Lens (Inline ann) (Inline ann) ann ann
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Inline ann -> ann
forall p. Inline p -> p
f Inline ann -> ann -> Inline ann
g
      where
        f :: Inline p -> p
f = \case
            InlineFork  TaggedLines p
x -> Optic' A_Lens NoIx (TaggedLines p) p -> TaggedLines p -> p
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' A_Lens NoIx (TaggedLines p) p
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation TaggedLines p
x
            InlinePlain Fragment p
x -> Optic' A_Lens NoIx (Fragment p) p -> Fragment p -> p
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' A_Lens NoIx (Fragment p) p
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation Fragment p
x
        g :: Inline ann -> ann -> Inline ann
g = \case
            InlineFork  TaggedLines ann
x -> \ann
a -> TaggedLines ann -> Inline ann
forall ann. TaggedLines ann -> Inline ann
InlineFork  (Optic A_Lens NoIx (TaggedLines ann) (TaggedLines ann) ann ann
-> ann -> TaggedLines ann -> TaggedLines ann
forall k (is :: IxList) s t a b.
Is k A_Setter =>
Optic k is s t a b -> b -> s -> t
set Optic A_Lens NoIx (TaggedLines ann) (TaggedLines ann) ann ann
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation ann
a TaggedLines ann
x)
            InlinePlain Fragment ann
x -> \ann
a -> Fragment ann -> Inline ann
forall ann. Fragment ann -> Inline ann
InlinePlain (Optic A_Lens NoIx (Fragment ann) (Fragment ann) ann ann
-> ann -> Fragment ann -> Fragment ann
forall k (is :: IxList) s t a b.
Is k A_Setter =>
Optic k is s t a b -> b -> s -> t
set Optic A_Lens NoIx (Fragment ann) (Fragment ann) ann ann
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation ann
a Fragment ann
x)

instance HasManyPlainInlines (Inline ann) where
    allPlainInlines :: Traversal' (Inline ann) (Fragment (Annotation (Inline ann)))
allPlainInlines = Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (Fragment ann)
  (Fragment ann)
forall x. CanBePlain x => Prism' x (Plain x)
plain Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (Fragment ann)
  (Fragment ann)
-> Optic' A_Traversal NoIx (Inline ann) (Fragment ann)
-> Optic' A_Traversal NoIx (Inline ann) (Fragment ann)
forall k l (is :: IxList) s a (js :: IxList).
(Is k A_Traversal, Is l A_Traversal) =>
Optic' k is s a -> Optic' l js s a -> Traversal' s a
`adjoin` (Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
forall x. CanFork x => Prism' x (Fork x)
fork Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
-> Optic
     A_Traversal
     NoIx
     (TaggedLines ann)
     (TaggedLines ann)
     (Fragment ann)
     (Fragment ann)
-> Optic' A_Traversal NoIx (Inline ann) (Fragment ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Fragment ann)
  (Fragment ann)
forall x.
HasManyPlainInlines x =>
Traversal' x (Fragment (Annotation x))
allPlainInlines)

instance HasTag (Inline ann) where
    type TagOpticKind (Inline ann) = An_AffineTraversal
    tag :: Optic'
  (TagOpticKind (Inline ann))
  NoIx
  (Inline ann)
  (Tag (Annotation (Inline ann)))
tag = (Inline ann -> Either (Inline ann) (Tag ann))
-> (Inline ann -> Tag ann -> Inline ann)
-> AffineTraversal (Inline ann) (Inline ann) (Tag ann) (Tag ann)
forall s t a b.
(s -> Either t a) -> (s -> b -> t) -> AffineTraversal s t a b
atraversal Inline ann -> Either (Inline ann) (Tag ann)
forall ann. Inline ann -> Either (Inline ann) (Tag ann)
f Inline ann -> Tag ann -> Inline ann
forall ann. Inline ann -> Tag ann -> Inline ann
g
      where
        f :: Inline ann -> Either (Inline ann) (Tag ann)
f = \case
            InlineFork TaggedLines ann
x -> Tag ann -> Either (Inline ann) (Tag ann)
forall a b. b -> Either a b
Right (Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
-> TaggedLines ann -> Tag ann
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag TaggedLines ann
x)
            Inline ann
x -> Inline ann -> Either (Inline ann) (Tag ann)
forall a b. a -> Either a b
Left Inline ann
x
        g :: Inline ann -> Tag ann -> Inline ann
g = \case
            InlineFork TaggedLines ann
x -> \Tag ann
a -> TaggedLines ann -> Inline ann
forall ann. TaggedLines ann -> Inline ann
InlineFork (Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
-> Tag ann -> TaggedLines ann -> TaggedLines ann
forall k (is :: IxList) s t a b.
Is k A_Setter =>
Optic k is s t a b -> b -> s -> t
set Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Tag ann
a TaggedLines ann
x)
            Inline ann
x -> \Tag ann
_ -> Inline ann
x

instance HasManyTags (Inline ann) where
    allTags :: Traversal' (Inline ann) (Tag (Annotation (Inline ann)))
allTags = Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
forall x. CanFork x => Prism' x (Fork x)
fork Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
-> Optic
     A_Traversal
     NoIx
     (TaggedLines ann)
     (TaggedLines ann)
     (Tag ann)
     (Tag ann)
-> Optic
     A_Traversal NoIx (Inline ann) (Inline ann) (Tag ann) (Tag ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Tag ann)
  (Tag ann)
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags
    allInlineTags :: Traversal' (Inline ann) (Tag (Annotation (Inline ann)))
allInlineTags = Traversal' (Inline ann) (Tag (Annotation (Inline ann)))
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags

instance HasManyMetadata (Inline ann) where
    allMetadata :: Traversal' (Inline ann) Metadata
allMetadata = Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
forall x. CanFork x => Prism' x (Fork x)
fork Optic
  A_Prism
  NoIx
  (Inline ann)
  (Inline ann)
  (TaggedLines ann)
  (TaggedLines ann)
-> Optic
     A_Traversal
     NoIx
     (TaggedLines ann)
     (TaggedLines ann)
     Metadata
     Metadata
-> Traversal' (Inline ann) Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  Metadata
  Metadata
forall x. HasManyMetadata x => Traversal' x Metadata
allMetadata

instance CanFork (Inline ann) where
    fork :: Prism' (Inline ann) (Fork (Inline ann))
fork = (TaggedLines ann -> Inline ann)
-> (Inline ann -> Maybe (TaggedLines ann))
-> Prism
     (Inline ann) (Inline ann) (TaggedLines ann) (TaggedLines ann)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' TaggedLines ann -> Inline ann
forall ann. TaggedLines ann -> Inline ann
InlineFork \case{ InlineFork TaggedLines ann
t -> TaggedLines ann -> Maybe (TaggedLines ann)
forall a. a -> Maybe a
Just TaggedLines ann
t; Inline ann
_ -> Maybe (TaggedLines ann)
forall a. Maybe a
Nothing }

instance CanBePlain (Inline ann) where
    plain :: Prism' (Inline ann) (Plain (Inline ann))
plain = (Fragment ann -> Inline ann)
-> (Inline ann -> Maybe (Fragment ann))
-> Prism (Inline ann) (Inline ann) (Fragment ann) (Fragment ann)
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' Fragment ann -> Inline ann
forall ann. Fragment ann -> Inline ann
InlinePlain \case{ InlinePlain Fragment ann
t -> Fragment ann -> Maybe (Fragment ann)
forall a. a -> Maybe a
Just Fragment ann
t; Inline ann
_ -> Maybe (Fragment ann)
forall a. Maybe a
Nothing }


-- ⭐ Line

data Line ann = Line
    { Line ann -> Seq (Inline ann)
lineInlines :: Seq (Inline ann) -- ^ 'ProAbstract.contentsSeq'
    , Line ann -> ann
lineAnnotation :: ann -- ^ 'ProAbstract.annotation'
    }
  deriving stock (Line ann -> Line ann -> Bool
(Line ann -> Line ann -> Bool)
-> (Line ann -> Line ann -> Bool) -> Eq (Line ann)
forall ann. Eq ann => Line ann -> Line ann -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Line ann -> Line ann -> Bool
$c/= :: forall ann. Eq ann => Line ann -> Line ann -> Bool
== :: Line ann -> Line ann -> Bool
$c== :: forall ann. Eq ann => Line ann -> Line ann -> Bool
Eq, Int -> Line ann -> ShowS
[Line ann] -> ShowS
Line ann -> String
(Int -> Line ann -> ShowS)
-> (Line ann -> String) -> ([Line ann] -> ShowS) -> Show (Line ann)
forall ann. Show ann => Int -> Line ann -> ShowS
forall ann. Show ann => [Line ann] -> ShowS
forall ann. Show ann => Line ann -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Line ann] -> ShowS
$cshowList :: forall ann. Show ann => [Line ann] -> ShowS
show :: Line ann -> String
$cshow :: forall ann. Show ann => Line ann -> String
showsPrec :: Int -> Line ann -> ShowS
$cshowsPrec :: forall ann. Show ann => Int -> Line ann -> ShowS
Show, (forall x. Line ann -> Rep (Line ann) x)
-> (forall x. Rep (Line ann) x -> Line ann) -> Generic (Line ann)
forall x. Rep (Line ann) x -> Line ann
forall x. Line ann -> Rep (Line ann) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ann x. Rep (Line ann) x -> Line ann
forall ann x. Line ann -> Rep (Line ann) x
$cto :: forall ann x. Rep (Line ann) x -> Line ann
$cfrom :: forall ann x. Line ann -> Rep (Line ann) x
Generic)
  deriving anyclass (Eq (Line ann)
Eq (Line ann)
-> (Int -> Line ann -> Int)
-> (Line ann -> Int)
-> Hashable (Line ann)
Int -> Line ann -> Int
Line ann -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ann. Hashable ann => Eq (Line ann)
forall ann. Hashable ann => Int -> Line ann -> Int
forall ann. Hashable ann => Line ann -> Int
hash :: Line ann -> Int
$chash :: forall ann. Hashable ann => Line ann -> Int
hashWithSalt :: Int -> Line ann -> Int
$chashWithSalt :: forall ann. Hashable ann => Int -> Line ann -> Int
$cp1Hashable :: forall ann. Hashable ann => Eq (Line ann)
Hashable, Line ann -> ()
(Line ann -> ()) -> NFData (Line ann)
forall ann. NFData ann => Line ann -> ()
forall a. (a -> ()) -> NFData a
rnf :: Line ann -> ()
$crnf :: forall ann. NFData ann => Line ann -> ()
NFData)

instance IsList (Line ()) where
    type Item (Line ()) = Inline ()
    toList :: Line () -> [Item (Line ())]
toList (Line Seq (Inline ())
xs ()) = Seq (Inline ()) -> [Item (Seq (Inline ()))]
forall l. IsList l => l -> [Item l]
toList Seq (Inline ())
xs
    fromList :: [Item (Line ())] -> Line ()
fromList [Item (Line ())]
xs = Seq (Inline ()) -> () -> Line ()
forall ann. Seq (Inline ann) -> ann -> Line ann
Line ([Item (Seq (Inline ()))] -> Seq (Inline ())
forall l. IsList l => [Item l] -> l
fromList [Item (Seq (Inline ()))]
[Item (Line ())]
xs) ()

type instance Contents (Line ann) = Inline ann

instance HasContents (Line ann) (Line ann) where
    contents :: Lens
  (Line ann)
  (Line ann)
  (Seq (Contents (Line ann)))
  (Seq (Contents (Line ann)))
contents = (Line ann -> Seq (Inline ann))
-> (Line ann -> Seq (Inline ann) -> Line ann)
-> Lens (Line ann) (Line ann) (Seq (Inline ann)) (Seq (Inline ann))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Line ann -> Seq (Inline ann)
forall ann. Line ann -> Seq (Inline ann)
lineInlines \Line ann
x Seq (Inline ann)
a -> Line ann
x{ lineInlines :: Seq (Inline ann)
lineInlines = Seq (Inline ann)
a }

type instance Annotation (Line ann) = ann

instance HasAnnotation (Line ann) (Line ann) where
    annotation :: Lens
  (Line ann)
  (Line ann)
  (Annotation (Line ann))
  (Annotation (Line ann))
annotation = (Line ann -> ann)
-> (Line ann -> ann -> Line ann)
-> Lens (Line ann) (Line ann) ann ann
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens Line ann -> ann
forall ann. Line ann -> ann
lineAnnotation \Line ann
x ann
a -> Line ann
x{ lineAnnotation :: ann
lineAnnotation = ann
a }

instance HasManyPlainInlines (Line ann) where
    allPlainInlines :: Traversal' (Line ann) (Fragment (Annotation (Line ann)))
allPlainInlines = Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Inline ann))
     (Seq (Inline ann))
     (Inline ann)
     (Inline ann)
-> Optic
     A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Inline ann))
  (Seq (Inline ann))
  (Inline ann)
  (Inline ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
-> Optic
     A_Traversal
     NoIx
     (Inline ann)
     (Inline ann)
     (Fragment ann)
     (Fragment ann)
-> Optic
     A_Traversal
     NoIx
     (Line ann)
     (Line ann)
     (Fragment ann)
     (Fragment ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Inline ann)
  (Inline ann)
  (Fragment ann)
  (Fragment ann)
forall x.
HasManyPlainInlines x =>
Traversal' x (Fragment (Annotation x))
allPlainInlines

instance HasManyAnnotations (Line ann) (Line ann') where
    allAnnotations :: Traversal
  (Line ann)
  (Line ann')
  (Annotation (Line ann))
  (Annotation (Line ann'))
allAnnotations = TraversalVL (Line ann) (Line ann') ann ann'
-> Traversal (Line ann) (Line ann') ann ann'
forall s t a b. TraversalVL s t a b -> Traversal s t a b
traversalVL \ann -> f ann'
f (Line xs a) ->
        Seq (Inline ann') -> ann' -> Line ann'
forall ann. Seq (Inline ann) -> ann -> Line ann
Line (Seq (Inline ann') -> ann' -> Line ann')
-> f (Seq (Inline ann')) -> f (ann' -> Line ann')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic
  A_Traversal NoIx (Seq (Inline ann)) (Seq (Inline ann')) ann ann'
-> (ann -> f ann') -> Seq (Inline ann) -> f (Seq (Inline ann'))
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf (Traversal
  (Seq (Inline ann)) (Seq (Inline ann')) (Inline ann) (Inline ann')
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Traversal
  (Seq (Inline ann)) (Seq (Inline ann')) (Inline ann) (Inline ann')
-> Optic A_Traversal NoIx (Inline ann) (Inline ann') ann ann'
-> Optic
     A_Traversal NoIx (Seq (Inline ann)) (Seq (Inline ann')) ann ann'
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Inline ann) (Inline ann') ann ann'
forall x x'.
HasManyAnnotations x x' =>
Traversal x x' (Annotation x) (Annotation x')
allAnnotations) ann -> f ann'
f Seq (Inline ann)
xs f (ann' -> Line ann') -> f ann' -> f (Line ann')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ann -> f ann'
f ann
a

instance HasManyMetadata (Line ann) where
    allMetadata :: Traversal' (Line ann) Metadata
allMetadata = Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Inline ann))
     (Seq (Inline ann))
     (Inline ann)
     (Inline ann)
-> Optic
     A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Inline ann))
  (Seq (Inline ann))
  (Inline ann)
  (Inline ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
-> Optic
     A_Traversal NoIx (Inline ann) (Inline ann) Metadata Metadata
-> Traversal' (Line ann) Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Inline ann) (Inline ann) Metadata Metadata
forall x. HasManyMetadata x => Traversal' x Metadata
allMetadata

instance HasManyTags (Line ann) where
    allTags :: Traversal' (Line ann) (Tag (Annotation (Line ann)))
allTags = Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Inline ann))
     (Seq (Inline ann))
     (Inline ann)
     (Inline ann)
-> Optic
     A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Inline ann))
  (Seq (Inline ann))
  (Inline ann)
  (Inline ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Line ann) (Line ann) (Inline ann) (Inline ann)
-> Optic
     A_Traversal NoIx (Inline ann) (Inline ann) (Tag ann) (Tag ann)
-> Optic A_Traversal NoIx (Line ann) (Line ann) (Tag ann) (Tag ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal NoIx (Inline ann) (Inline ann) (Tag ann) (Tag ann)
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags
    allInlineTags :: Traversal' (Line ann) (Tag (Annotation (Line ann)))
allInlineTags = Traversal' (Line ann) (Tag (Annotation (Line ann)))
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags

instance HasWitherableInlineTags (Line ann) where
    witherInlineTags :: (Tag (Annotation (Line ann))
 -> f (Maybe (Tag (Annotation (Line ann)))))
-> Line ann -> f (Line ann)
witherInlineTags = (Tag (Annotation (Line ann))
 -> f (Maybe (Tag (Annotation (Line ann)))))
-> Line ann -> f (Line ann)
forall x (f :: * -> *).
(HasWitherableTags x, Monad f) =>
(Tag (Annotation x) -> f (Maybe (Tag (Annotation x)))) -> x -> f x
witherTags

instance HasWitherableTags (Line ann) where
    witherTags :: (Tag (Annotation (Line ann))
 -> f (Maybe (Tag (Annotation (Line ann)))))
-> Line ann -> f (Line ann)
witherTags Tag (Annotation (Line ann))
-> f (Maybe (Tag (Annotation (Line ann))))
f = Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
-> (Seq (Inline ann) -> f (Seq (Inline ann)))
-> Line ann
-> f (Line ann)
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic
  A_Lens
  NoIx
  (Line ann)
  (Line ann)
  (Seq (Inline ann))
  (Seq (Inline ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents ((Seq (Inline ann) -> f (Seq (Inline ann)))
 -> Line ann -> f (Line ann))
-> (Seq (Inline ann) -> f (Seq (Inline ann)))
-> Line ann
-> f (Line ann)
forall a b. (a -> b) -> a -> b
$
        (Inline ann -> f (Maybe (Inline ann)))
-> Seq (Inline ann) -> f (Seq (Inline ann))
forall (f :: * -> *) a b.
Applicative f =>
(a -> f (Maybe b)) -> Seq a -> f (Seq b)
seqWither \case
            InlinePlain Fragment ann
x -> Maybe (Inline ann) -> f (Maybe (Inline ann))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Inline ann) -> f (Maybe (Inline ann)))
-> (Fragment ann -> Maybe (Inline ann))
-> Fragment ann
-> f (Maybe (Inline ann))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inline ann -> Maybe (Inline ann)
forall a. a -> Maybe a
Just (Inline ann -> Maybe (Inline ann))
-> (Fragment ann -> Inline ann)
-> Fragment ann
-> Maybe (Inline ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fragment ann -> Inline ann
forall ann. Fragment ann -> Inline ann
InlinePlain (Fragment ann -> f (Maybe (Inline ann)))
-> Fragment ann -> f (Maybe (Inline ann))
forall a b. (a -> b) -> a -> b
$ Fragment ann
x
            InlineFork TaggedLines ann
x -> Tag (Annotation (Line ann))
-> f (Maybe (Tag (Annotation (Line ann))))
f (Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
-> TaggedLines ann -> Tag ann
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag TaggedLines ann
x) f (Maybe (Tag ann))
-> (Maybe (Tag ann) -> f (Maybe (Inline ann)))
-> f (Maybe (Inline ann))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
                Maybe (Tag ann)
Nothing -> Maybe (Inline ann) -> f (Maybe (Inline ann))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Inline ann)
forall a. Maybe a
Nothing
                Just Tag ann
t -> Inline ann -> Maybe (Inline ann)
forall a. a -> Maybe a
Just (Inline ann -> Maybe (Inline ann))
-> (TaggedLines ann -> Inline ann)
-> TaggedLines ann
-> Maybe (Inline ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedLines ann -> Inline ann
forall ann. TaggedLines ann -> Inline ann
InlineFork (TaggedLines ann -> Inline ann)
-> (TaggedLines ann -> TaggedLines ann)
-> TaggedLines ann
-> Inline ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
-> Tag ann -> TaggedLines ann -> TaggedLines ann
forall k (is :: IxList) s t a b.
Is k A_Setter =>
Optic k is s t a b -> b -> s -> t
set Optic' A_Lens NoIx (TaggedLines ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Tag ann
t (TaggedLines ann -> Maybe (Inline ann))
-> f (TaggedLines ann) -> f (Maybe (Inline ann))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
-> (Lines ann -> f (Lines ann))
-> TaggedLines ann
-> f (TaggedLines ann)
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
forall x x'. HasContent x x' => Lens x x' (Content x) (Content x')
content ((Tag (Annotation (Lines ann))
 -> f (Maybe (Tag (Annotation (Lines ann)))))
-> Lines ann -> f (Lines ann)
forall x (f :: * -> *).
(HasWitherableTags x, Monad f) =>
(Tag (Annotation x) -> f (Maybe (Tag (Annotation x)))) -> x -> f x
witherTags Tag (Annotation (Lines ann))
-> f (Maybe (Tag (Annotation (Lines ann))))
Tag (Annotation (Line ann))
-> f (Maybe (Tag (Annotation (Line ann))))
f) TaggedLines ann
x


-- ⭐ Lines

newtype Lines ann =
  Lines
    (Seq (Line ann)) -- ^ 'ProAbstract.contentsSeq'
  deriving stock (Lines ann -> Lines ann -> Bool
(Lines ann -> Lines ann -> Bool)
-> (Lines ann -> Lines ann -> Bool) -> Eq (Lines ann)
forall ann. Eq ann => Lines ann -> Lines ann -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lines ann -> Lines ann -> Bool
$c/= :: forall ann. Eq ann => Lines ann -> Lines ann -> Bool
== :: Lines ann -> Lines ann -> Bool
$c== :: forall ann. Eq ann => Lines ann -> Lines ann -> Bool
Eq, Int -> Lines ann -> ShowS
[Lines ann] -> ShowS
Lines ann -> String
(Int -> Lines ann -> ShowS)
-> (Lines ann -> String)
-> ([Lines ann] -> ShowS)
-> Show (Lines ann)
forall ann. Show ann => Int -> Lines ann -> ShowS
forall ann. Show ann => [Lines ann] -> ShowS
forall ann. Show ann => Lines ann -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lines ann] -> ShowS
$cshowList :: forall ann. Show ann => [Lines ann] -> ShowS
show :: Lines ann -> String
$cshow :: forall ann. Show ann => Lines ann -> String
showsPrec :: Int -> Lines ann -> ShowS
$cshowsPrec :: forall ann. Show ann => Int -> Lines ann -> ShowS
Show, (forall x. Lines ann -> Rep (Lines ann) x)
-> (forall x. Rep (Lines ann) x -> Lines ann)
-> Generic (Lines ann)
forall x. Rep (Lines ann) x -> Lines ann
forall x. Lines ann -> Rep (Lines ann) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ann x. Rep (Lines ann) x -> Lines ann
forall ann x. Lines ann -> Rep (Lines ann) x
$cto :: forall ann x. Rep (Lines ann) x -> Lines ann
$cfrom :: forall ann x. Lines ann -> Rep (Lines ann) x
Generic)
  deriving anyclass (Eq (Lines ann)
Eq (Lines ann)
-> (Int -> Lines ann -> Int)
-> (Lines ann -> Int)
-> Hashable (Lines ann)
Int -> Lines ann -> Int
Lines ann -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ann. Hashable ann => Eq (Lines ann)
forall ann. Hashable ann => Int -> Lines ann -> Int
forall ann. Hashable ann => Lines ann -> Int
hash :: Lines ann -> Int
$chash :: forall ann. Hashable ann => Lines ann -> Int
hashWithSalt :: Int -> Lines ann -> Int
$chashWithSalt :: forall ann. Hashable ann => Int -> Lines ann -> Int
$cp1Hashable :: forall ann. Hashable ann => Eq (Lines ann)
Hashable, Lines ann -> ()
(Lines ann -> ()) -> NFData (Lines ann)
forall ann. NFData ann => Lines ann -> ()
forall a. (a -> ()) -> NFData a
rnf :: Lines ann -> ()
$crnf :: forall ann. NFData ann => Lines ann -> ()
NFData)
  deriving newtype (b -> Lines ann -> Lines ann
NonEmpty (Lines ann) -> Lines ann
Lines ann -> Lines ann -> Lines ann
(Lines ann -> Lines ann -> Lines ann)
-> (NonEmpty (Lines ann) -> Lines ann)
-> (forall b. Integral b => b -> Lines ann -> Lines ann)
-> Semigroup (Lines ann)
forall b. Integral b => b -> Lines ann -> Lines ann
forall ann. NonEmpty (Lines ann) -> Lines ann
forall ann. Lines ann -> Lines ann -> Lines ann
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall ann b. Integral b => b -> Lines ann -> Lines ann
stimes :: b -> Lines ann -> Lines ann
$cstimes :: forall ann b. Integral b => b -> Lines ann -> Lines ann
sconcat :: NonEmpty (Lines ann) -> Lines ann
$csconcat :: forall ann. NonEmpty (Lines ann) -> Lines ann
<> :: Lines ann -> Lines ann -> Lines ann
$c<> :: forall ann. Lines ann -> Lines ann -> Lines ann
Semigroup, Semigroup (Lines ann)
Lines ann
Semigroup (Lines ann)
-> Lines ann
-> (Lines ann -> Lines ann -> Lines ann)
-> ([Lines ann] -> Lines ann)
-> Monoid (Lines ann)
[Lines ann] -> Lines ann
Lines ann -> Lines ann -> Lines ann
forall ann. Semigroup (Lines ann)
forall ann. Lines ann
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall ann. [Lines ann] -> Lines ann
forall ann. Lines ann -> Lines ann -> Lines ann
mconcat :: [Lines ann] -> Lines ann
$cmconcat :: forall ann. [Lines ann] -> Lines ann
mappend :: Lines ann -> Lines ann -> Lines ann
$cmappend :: forall ann. Lines ann -> Lines ann -> Lines ann
mempty :: Lines ann
$cmempty :: forall ann. Lines ann
$cp1Monoid :: forall ann. Semigroup (Lines ann)
Monoid)

instance IsList (Lines ann) where
    type Item (Lines ann) = Line ann
    toList :: Lines ann -> [Item (Lines ann)]
toList (Lines Seq (Line ann)
xs) = Seq (Line ann) -> [Item (Seq (Line ann))]
forall l. IsList l => l -> [Item l]
toList Seq (Line ann)
xs
    fromList :: [Item (Lines ann)] -> Lines ann
fromList [Item (Lines ann)]
xs = Seq (Line ann) -> Lines ann
forall ann. Seq (Line ann) -> Lines ann
Lines ([Item (Seq (Line ann))] -> Seq (Line ann)
forall l. IsList l => [Item l] -> l
fromList [Item (Seq (Line ann))]
[Item (Lines ann)]
xs)

type instance Contents (Lines ann) = Line ann

instance HasContents (Lines ann) (Lines ann') where
    contents :: Lens
  (Lines ann)
  (Lines ann')
  (Seq (Contents (Lines ann)))
  (Seq (Contents (Lines ann')))
contents = Optic
  An_Iso
  NoIx
  (Lines ann)
  (Lines ann')
  (Seq (Line ann))
  (Seq (Line ann'))
-> Optic
     A_Lens
     NoIx
     (Lines ann)
     (Lines ann')
     (Seq (Line ann))
     (Seq (Line ann'))
forall destKind srcKind (is :: IxList) s t a b.
Is srcKind destKind =>
Optic srcKind is s t a b -> Optic destKind is s t a b
castOptic Optic
  An_Iso
  NoIx
  (Lines ann)
  (Lines ann')
  (Seq (Line ann))
  (Seq (Line ann'))
forall s a t b. (Coercible s a, Coercible t b) => Iso s t a b
coerced

type instance Annotation (Lines ann) = ann

instance HasManyPlainInlines (Lines ann) where
    allPlainInlines :: Traversal' (Lines ann) (Fragment (Annotation (Lines ann)))
allPlainInlines = Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Line ann))
     (Seq (Line ann))
     (Line ann)
     (Line ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Line ann))
  (Seq (Line ann))
  (Line ann)
  (Line ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
-> Optic
     A_Traversal
     NoIx
     (Line ann)
     (Line ann)
     (Fragment ann)
     (Fragment ann)
-> Optic
     A_Traversal
     NoIx
     (Lines ann)
     (Lines ann)
     (Fragment ann)
     (Fragment ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Line ann)
  (Line ann)
  (Fragment ann)
  (Fragment ann)
forall x.
HasManyPlainInlines x =>
Traversal' x (Fragment (Annotation x))
allPlainInlines

instance HasManyAnnotations (Lines ann) (Lines ann') where
    allAnnotations :: Traversal
  (Lines ann)
  (Lines ann')
  (Annotation (Lines ann))
  (Annotation (Lines ann'))
allAnnotations = Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann')
  (Seq (Line ann))
  (Seq (Line ann'))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann')
  (Seq (Line ann))
  (Seq (Line ann'))
-> Optic
     A_Traversal
     NoIx
     (Seq (Line ann))
     (Seq (Line ann'))
     (Line ann)
     (Line ann')
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann') (Line ann) (Line ann')
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Line ann))
  (Seq (Line ann'))
  (Line ann)
  (Line ann')
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Lines ann) (Lines ann') (Line ann) (Line ann')
-> Optic A_Traversal NoIx (Line ann) (Line ann') ann ann'
-> Optic A_Traversal NoIx (Lines ann) (Lines ann') ann ann'
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Line ann) (Line ann') ann ann'
forall x x'.
HasManyAnnotations x x' =>
Traversal x x' (Annotation x) (Annotation x')
allAnnotations

instance HasManyMetadata (Lines ann) where
    allMetadata :: Traversal' (Lines ann) Metadata
allMetadata = Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Line ann))
     (Seq (Line ann))
     (Line ann)
     (Line ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Line ann))
  (Seq (Line ann))
  (Line ann)
  (Line ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
-> Optic A_Traversal NoIx (Line ann) (Line ann) Metadata Metadata
-> Traversal' (Lines ann) Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Line ann) (Line ann) Metadata Metadata
forall x. HasManyMetadata x => Traversal' x Metadata
allMetadata

instance HasManyTags (Lines ann) where
    allTags :: Traversal' (Lines ann) (Tag (Annotation (Lines ann)))
allTags = Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Line ann))
     (Seq (Line ann))
     (Line ann)
     (Line ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Line ann))
  (Seq (Line ann))
  (Line ann)
  (Line ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed Optic
  A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
-> Optic A_Traversal NoIx (Line ann) (Line ann) (Tag ann) (Tag ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Tag ann) (Tag ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Line ann) (Line ann) (Tag ann) (Tag ann)
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags
    allInlineTags :: Traversal' (Lines ann) (Tag (Annotation (Lines ann)))
allInlineTags = Traversal' (Lines ann) (Tag (Annotation (Lines ann)))
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags

instance HasWitherableInlineTags (Lines ann) where
    witherInlineTags :: (Tag (Annotation (Lines ann))
 -> f (Maybe (Tag (Annotation (Lines ann)))))
-> Lines ann -> f (Lines ann)
witherInlineTags = (Tag (Annotation (Lines ann))
 -> f (Maybe (Tag (Annotation (Lines ann)))))
-> Lines ann -> f (Lines ann)
forall x (f :: * -> *).
(HasWitherableTags x, Monad f) =>
(Tag (Annotation x) -> f (Maybe (Tag (Annotation x)))) -> x -> f x
witherTags

instance HasWitherableTags (Lines ann) where
    witherTags :: (Tag (Annotation (Lines ann))
 -> f (Maybe (Tag (Annotation (Lines ann)))))
-> Lines ann -> f (Lines ann)
witherTags Tag (Annotation (Lines ann))
-> f (Maybe (Tag (Annotation (Lines ann))))
f = Optic
  A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
-> (Line ann -> f (Line ann)) -> Lines ann -> f (Lines ann)
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf (Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
-> Optic
     A_Traversal
     NoIx
     (Seq (Line ann))
     (Seq (Line ann))
     (Line ann)
     (Line ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Line ann) (Line ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Seq (Line ann))
  (Seq (Line ann))
  (Line ann)
  (Line ann)
forall (t :: * -> *) a b.
Traversable t =>
Traversal (t a) (t b) a b
traversed) ((Tag (Annotation (Line ann))
 -> f (Maybe (Tag (Annotation (Line ann)))))
-> Line ann -> f (Line ann)
forall x (f :: * -> *).
(HasWitherableTags x, Monad f) =>
(Tag (Annotation x) -> f (Maybe (Tag (Annotation x)))) -> x -> f x
witherTags Tag (Annotation (Lines ann))
-> f (Maybe (Tag (Annotation (Lines ann))))
Tag (Annotation (Line ann))
-> f (Maybe (Tag (Annotation (Line ann))))
f)


-- ⭐ TaggedLines

data TaggedLines ann =
  TaggedLines
    { TaggedLines ann -> Tag ann
linesTag :: Tag ann -- ^ 'ProAbstract.tag'
    , TaggedLines ann -> Lines ann
taggedLines :: Lines ann -- ^ 'ProAbstract.content'
    }
  deriving stock (TaggedLines ann -> TaggedLines ann -> Bool
(TaggedLines ann -> TaggedLines ann -> Bool)
-> (TaggedLines ann -> TaggedLines ann -> Bool)
-> Eq (TaggedLines ann)
forall ann. Eq ann => TaggedLines ann -> TaggedLines ann -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TaggedLines ann -> TaggedLines ann -> Bool
$c/= :: forall ann. Eq ann => TaggedLines ann -> TaggedLines ann -> Bool
== :: TaggedLines ann -> TaggedLines ann -> Bool
$c== :: forall ann. Eq ann => TaggedLines ann -> TaggedLines ann -> Bool
Eq, Int -> TaggedLines ann -> ShowS
[TaggedLines ann] -> ShowS
TaggedLines ann -> String
(Int -> TaggedLines ann -> ShowS)
-> (TaggedLines ann -> String)
-> ([TaggedLines ann] -> ShowS)
-> Show (TaggedLines ann)
forall ann. Show ann => Int -> TaggedLines ann -> ShowS
forall ann. Show ann => [TaggedLines ann] -> ShowS
forall ann. Show ann => TaggedLines ann -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TaggedLines ann] -> ShowS
$cshowList :: forall ann. Show ann => [TaggedLines ann] -> ShowS
show :: TaggedLines ann -> String
$cshow :: forall ann. Show ann => TaggedLines ann -> String
showsPrec :: Int -> TaggedLines ann -> ShowS
$cshowsPrec :: forall ann. Show ann => Int -> TaggedLines ann -> ShowS
Show, (forall x. TaggedLines ann -> Rep (TaggedLines ann) x)
-> (forall x. Rep (TaggedLines ann) x -> TaggedLines ann)
-> Generic (TaggedLines ann)
forall x. Rep (TaggedLines ann) x -> TaggedLines ann
forall x. TaggedLines ann -> Rep (TaggedLines ann) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall ann x. Rep (TaggedLines ann) x -> TaggedLines ann
forall ann x. TaggedLines ann -> Rep (TaggedLines ann) x
$cto :: forall ann x. Rep (TaggedLines ann) x -> TaggedLines ann
$cfrom :: forall ann x. TaggedLines ann -> Rep (TaggedLines ann) x
Generic)
  deriving anyclass (Eq (TaggedLines ann)
Eq (TaggedLines ann)
-> (Int -> TaggedLines ann -> Int)
-> (TaggedLines ann -> Int)
-> Hashable (TaggedLines ann)
Int -> TaggedLines ann -> Int
TaggedLines ann -> Int
forall a. Eq a -> (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall ann. Hashable ann => Eq (TaggedLines ann)
forall ann. Hashable ann => Int -> TaggedLines ann -> Int
forall ann. Hashable ann => TaggedLines ann -> Int
hash :: TaggedLines ann -> Int
$chash :: forall ann. Hashable ann => TaggedLines ann -> Int
hashWithSalt :: Int -> TaggedLines ann -> Int
$chashWithSalt :: forall ann. Hashable ann => Int -> TaggedLines ann -> Int
$cp1Hashable :: forall ann. Hashable ann => Eq (TaggedLines ann)
Hashable, TaggedLines ann -> ()
(TaggedLines ann -> ()) -> NFData (TaggedLines ann)
forall ann. NFData ann => TaggedLines ann -> ()
forall a. (a -> ()) -> NFData a
rnf :: TaggedLines ann -> ()
$crnf :: forall ann. NFData ann => TaggedLines ann -> ()
NFData)

type instance Annotation (TaggedLines ann) = ann

instance HasTag (TaggedLines ann) where
    type TagOpticKind (TaggedLines ann) = A_Lens
    tag :: Optic'
  (TagOpticKind (TaggedLines ann))
  NoIx
  (TaggedLines ann)
  (Tag (Annotation (TaggedLines ann)))
tag = (TaggedLines ann -> Tag ann)
-> (TaggedLines ann -> Tag ann -> TaggedLines ann)
-> Lens (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TaggedLines ann -> Tag ann
forall ann. TaggedLines ann -> Tag ann
linesTag \TaggedLines ann
x Tag ann
a -> TaggedLines ann
x{ linesTag :: Tag ann
linesTag = Tag ann
a }

type instance Content (TaggedLines ann) = Lines ann

type instance Contents (TaggedLines ann) = Line ann

instance HasManyAnnotations (TaggedLines ann) (TaggedLines ann') where
    allAnnotations :: Traversal
  (TaggedLines ann)
  (TaggedLines ann')
  (Annotation (TaggedLines ann))
  (Annotation (TaggedLines ann'))
allAnnotations = TraversalVL (TaggedLines ann) (TaggedLines ann') ann ann'
-> Traversal (TaggedLines ann) (TaggedLines ann') ann ann'
forall s t a b. TraversalVL s t a b -> Traversal s t a b
traversalVL \ann -> f ann'
f (TaggedLines t b) -> Tag ann' -> Lines ann' -> TaggedLines ann'
forall ann. Tag ann -> Lines ann -> TaggedLines ann
TaggedLines
        (Tag ann' -> Lines ann' -> TaggedLines ann')
-> f (Tag ann') -> f (Lines ann' -> TaggedLines ann')
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic A_Lens NoIx (Tag ann) (Tag ann') ann ann'
-> (ann -> f ann') -> Tag ann -> f (Tag ann')
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic A_Lens NoIx (Tag ann) (Tag ann') ann ann'
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation ann -> f ann'
f Tag ann
t f (Lines ann' -> TaggedLines ann')
-> f (Lines ann') -> f (TaggedLines ann')
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Optic A_Traversal NoIx (Lines ann) (Lines ann') ann ann'
-> (ann -> f ann') -> Lines ann -> f (Lines ann')
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic A_Traversal NoIx (Lines ann) (Lines ann') ann ann'
forall x x'.
HasManyAnnotations x x' =>
Traversal x x' (Annotation x) (Annotation x')
allAnnotations ann -> f ann'
f Lines ann
b

instance HasAnnotation (TaggedLines ann) (TaggedLines ann) where
     annotation :: Lens
  (TaggedLines ann)
  (TaggedLines ann)
  (Annotation (TaggedLines ann))
  (Annotation (TaggedLines ann))
annotation = Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
-> Optic A_Lens NoIx (Tag ann) (Tag ann) ann ann
-> Optic A_Lens NoIx (TaggedLines ann) (TaggedLines ann) ann ann
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens NoIx (Tag ann) (Tag ann) ann ann
forall x x'.
HasAnnotation x x' =>
Lens x x' (Annotation x) (Annotation x')
annotation

instance HasContent (TaggedLines ann) (TaggedLines ann) where
    content :: Lens
  (TaggedLines ann)
  (TaggedLines ann)
  (Content (TaggedLines ann))
  (Content (TaggedLines ann))
content = (TaggedLines ann -> Lines ann)
-> (TaggedLines ann -> Lines ann -> TaggedLines ann)
-> Lens (TaggedLines ann) (TaggedLines ann) (Lines ann) (Lines ann)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens TaggedLines ann -> Lines ann
forall ann. TaggedLines ann -> Lines ann
taggedLines \TaggedLines ann
x Lines ann
c -> TaggedLines ann
x{ taggedLines :: Lines ann
taggedLines = Lines ann
c }

instance HasContents (TaggedLines ann) (TaggedLines ann) where
    contents :: Lens
  (TaggedLines ann)
  (TaggedLines ann)
  (Seq (Contents (TaggedLines ann)))
  (Seq (Contents (TaggedLines ann)))
contents = Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
forall x x'. HasContent x x' => Lens x x' (Content x) (Content x')
content Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
-> Optic
     A_Lens
     NoIx
     (Lines ann)
     (Lines ann)
     (Seq (Line ann))
     (Seq (Line ann))
-> Optic
     A_Lens
     NoIx
     (TaggedLines ann)
     (TaggedLines ann)
     (Seq (Line ann))
     (Seq (Line ann))
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Lens
  NoIx
  (Lines ann)
  (Lines ann)
  (Seq (Line ann))
  (Seq (Line ann))
forall x x'.
HasContents x x' =>
Lens x x' (Seq (Contents x)) (Seq (Contents x'))
contents

instance HasMetadata (TaggedLines ann) where
    type MetadataOpticKind (TaggedLines ann) = A_Lens
    metadata :: Optic'
  (MetadataOpticKind (TaggedLines ann))
  NoIx
  (TaggedLines ann)
  Metadata
metadata = Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
-> Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
-> Optic
     A_Lens NoIx (TaggedLines ann) (TaggedLines ann) Metadata Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
forall x.
HasMetadata x =>
Optic' (MetadataOpticKind x) NoIx x Metadata
metadata

instance HasManyPlainInlines (TaggedLines ann) where
    allPlainInlines :: Traversal'
  (TaggedLines ann) (Fragment (Annotation (TaggedLines ann)))
allPlainInlines = Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
forall x x'. HasContent x x' => Lens x x' (Content x) (Content x')
content Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
-> Optic
     A_Traversal
     NoIx
     (Lines ann)
     (Lines ann)
     (Fragment ann)
     (Fragment ann)
-> Optic
     A_Traversal
     NoIx
     (TaggedLines ann)
     (TaggedLines ann)
     (Fragment ann)
     (Fragment ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic
  A_Traversal
  NoIx
  (Lines ann)
  (Lines ann)
  (Fragment ann)
  (Fragment ann)
forall x.
HasManyPlainInlines x =>
Traversal' x (Fragment (Annotation x))
allPlainInlines

instance HasManyTags (TaggedLines ann) where
    allTags :: Traversal' (TaggedLines ann) (Tag (Annotation (TaggedLines ann)))
allTags = Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
forall x.
HasTag x =>
Optic' (TagOpticKind x) NoIx x (Tag (Annotation x))
tag Optic
  A_Lens NoIx (TaggedLines ann) (TaggedLines ann) (Tag ann) (Tag ann)
-> Optic' A_Traversal NoIx (TaggedLines ann) (Tag ann)
-> Optic' A_Traversal NoIx (TaggedLines ann) (Tag ann)
forall k l (is :: IxList) s a (js :: IxList).
(Is k A_Traversal, Is l A_Traversal) =>
Optic' k is s a -> Optic' l js s a -> Traversal' s a
`adjoin` (Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
forall x x'. HasContent x x' => Lens x x' (Content x) (Content x')
content Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
-> Optic
     A_Traversal NoIx (Lines ann) (Lines ann) (Tag ann) (Tag ann)
-> Optic' A_Traversal NoIx (TaggedLines ann) (Tag ann)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Traversal NoIx (Lines ann) (Lines ann) (Tag ann) (Tag ann)
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags)
    allInlineTags :: Traversal' (TaggedLines ann) (Tag (Annotation (TaggedLines ann)))
allInlineTags = Traversal' (TaggedLines ann) (Tag (Annotation (TaggedLines ann)))
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags

instance HasWitherableInlineTags (TaggedLines ann) where
    witherInlineTags :: (Tag (Annotation (TaggedLines ann))
 -> f (Maybe (Tag (Annotation (TaggedLines ann)))))
-> TaggedLines ann -> f (TaggedLines ann)
witherInlineTags Tag (Annotation (TaggedLines ann))
-> f (Maybe (Tag (Annotation (TaggedLines ann))))
f = Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
-> (Lines ann -> f (Lines ann))
-> TaggedLines ann
-> f (TaggedLines ann)
forall k (f :: * -> *) (is :: IxList) s t a b.
(Is k A_Traversal, Applicative f) =>
Optic k is s t a b -> (a -> f b) -> s -> f t
traverseOf Optic
  A_Lens
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Lines ann)
  (Lines ann)
forall x x'. HasContent x x' => Lens x x' (Content x) (Content x')
content ((Tag (Annotation (Lines ann))
 -> f (Maybe (Tag (Annotation (Lines ann)))))
-> Lines ann -> f (Lines ann)
forall x (f :: * -> *).
(HasWitherableInlineTags x, Monad f) =>
(Tag (Annotation x) -> f (Maybe (Tag (Annotation x)))) -> x -> f x
witherInlineTags Tag (Annotation (TaggedLines ann))
-> f (Maybe (Tag (Annotation (TaggedLines ann))))
Tag (Annotation (Lines ann))
-> f (Maybe (Tag (Annotation (Lines ann))))
f)

instance HasManyMetadata (TaggedLines ann) where
   allMetadata :: Traversal' (TaggedLines ann) Metadata
allMetadata = Optic
  A_Traversal
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Tag ann)
  (Tag ann)
forall x. HasManyTags x => Traversal' x (Tag (Annotation x))
allTags Optic
  A_Traversal
  NoIx
  (TaggedLines ann)
  (TaggedLines ann)
  (Tag ann)
  (Tag ann)
-> Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
-> Traversal' (TaggedLines ann) Metadata
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Optic A_Lens NoIx (Tag ann) (Tag ann) Metadata Metadata
forall x.
HasMetadata x =>
Optic' (MetadataOpticKind x) NoIx x Metadata
metadata