pro-abstract 0.2.1.0 → 0.3.0.0

raw patch · 16 files changed

+126/−125 lines, 16 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• changelog.txt +10/−0
• library/pro-abstract/ProAbstract.hs +35/−31
• library/pro-abstract/ProAbstract/Datatypes.hs +2/−1
• library/pro-abstract/ProAbstract/Families.hs +0/−3
• library/pro-abstract/ProAbstract/Structure.hs +4/−5
• library/pro-abstract/ProAbstract/Structure/Block.hs +26/−26
• library/pro-abstract/ProAbstract/Structure/BlockTag.hs +4/−4
• library/pro-abstract/ProAbstract/Structure/HasManyPlainBlocks.hs +1/−1
• library/pro-abstract/ProAbstract/Structure/Inline.hs +20/−20
• library/pro-abstract/ProAbstract/Structure/IsTaggedOrBare.hs +1/−1
• library/pro-abstract/ProAbstract/Structure/PlainBlock.hs +14/−14
• library/pro-abstract/ProAbstract/Tag.hs +0/−2
• library/pro-abstract/ProAbstract/Tag/TaggedFamily.hs +0/−5
• library/pro-abstract/ProAbstract/Tagless/CanHaveTaglessContent.hs +5/−5
• library/pro-abstract/ProAbstract/Types.hs +3/−5
• pro-abstract.cabal +1/−2

@@ -21,3 +21,13 @@  v0.2.1.0 - Add:     MetaItem, MetaValue, metaMap, metaList++v0.3.0.0+    - Removes the 'Tagged' data family.+        - Tagged PlainBlock -> TaggedPlainBlock+        - Tagged Lines -> TaggedLines+        - Tagged Blocks -> TaggedBlocks+    - "ProAbstract.Types" no longer re-exports:+            Map, Seq, Set, and Text+      Import them directly from the 'containers'+      and 'text' packages instead.

@@ -13,24 +13,20 @@  === Tagged nodes -/Tagged/ nodes are branch points within a document.- - 'Tag' = ('name' : 'Text') × ('metadata' : 'Metadata') × ('annotation' : 'Annotation') -- 'Tagged' x = ('tag' : 'Tag') × ('content' : x)--'Tagged' is a data family, where the type parameter corresponds to the type of content under the tag. There are three instances of this family:+/Tagged/ nodes are branch points within a document. -- 'Tagged' 'Blocks'-- 'Tagged' 'PlainBlock'-- 'Tagged' 'Lines'+- 'TaggedBlocks'     = ('tag' : 'Tag') × ('content' : 'Blocks')+- 'TaggedPlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')+- 'TaggedLines'      = ('tag' : 'Tag') × ('content' : 'Lines')  Optics:  - 'tag' targets the tag at a node; it is either a lens or an affine traversal, depending on the node type. - The 'allTags' traversal targets every tag at and below a node. - The 'allBlockTags' and 'allInlineTags' also target tags at or below a node, but are limited to tags at the block or inline level, respectively.-- Since a tag has metadata, all of the optics for targeting parts of metadata (e.g. 'atSetting' and 'hasProperty') are also available on 'Tag' and on 'Tagged' nodes.+- Since a tag has metadata, all of the optics for targeting parts of metadata (e.g. 'atSetting' and 'hasProperty') are also available on 'Tag' and on @Tagged...@ nodes.  Operations for altering tags and/or removing tagged nodes in bulk: @@ -44,17 +40,17 @@  /Block-level/ content is everything that appears below the document level and above the paragraph level. -- 'Block' = ('fork' : 'Tagged' 'Blocks') ∪ ('plain' : 'Tagged' 'PlainBlock') ∪ ('bare' : 'Paragraph')+- 'Block' = ('fork' : 'TaggedBlocks') ∪ ('plain' : 'TaggedPlainBlock') ∪ ('bare' : 'Paragraph')  There are three kinds of block:  - /Fork/ blocks contain more blocks. -    * 'Tagged' 'Blocks' = ('tag' : 'Tag') × ('contents' : 'Block')+    * 'TaggedBlocks' = ('tag' : 'Tag') × ('contents' : 'Block')  - /Plain/ blocks contain text. -    * 'Tagged' 'PlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')+    * 'TaggedPlainBlock' = ('tag' : 'Tag') × ('content' : 'PlainBlock')     * 'PlainBlock' = ('contents' : 'Fragment') × ('annotation' : 'Annotation')  - /Bare/ blocks (paragraphs) contain inline content.@@ -68,7 +64,7 @@  A /BlockTag/ is a non-paragraph Block. -- 'BlockTag' = ('fork' : 'Tagged' 'Blocks') ∪ ('plain' : 'Tagged' 'PlainBlock')+- 'BlockTag' = ('fork' : 'TaggedBlocks') ∪ ('plain' : 'TaggedPlainBlock')  The Block type can be described in terms of BlockTag as: @@ -88,13 +84,13 @@  Inline content is grouped into lines; we specify no particular semantics of line breaks but suggest that a typical consumer of 'Lines' will fold them together with a single space character interspersed between the lines. -- 'Inline' = ('fork' or 'tagged' : 'Tagged' 'Lines') ∪ ('plain' or 'bare' : 'Fragment')+- 'Inline' = ('fork' or 'tagged' : 'TaggedLines') ∪ ('plain' or 'bare' : 'Fragment')  There are two kinds of inline:  - /Fork/ or /tag/ inlines contain more inlines. -    * 'Tagged' 'Lines' = ('tag' : 'Tag') × ('content' : 'Lines')+    * 'TaggedLines' = ('tag' : 'Tag') × ('content' : 'Lines')     * 'Lines' = ('contents' : 'Line')     * 'Line' = ('content' : 'Seq' 'Inline') × ('annotation' : 'Annotation') @@ -142,20 +138,24 @@ +-----------------------+-----------------------+-----------------------+ | 'Document'            | 'Blocks'              | 'Block'               | +-----------------------+-----------------------+-----------------------++| 'TaggedBlocks'        | 'Blocks'              | 'Block'               |++-----------------------+-----------------------+-----------------------+ | 'Blocks'              | —                     | 'Block'               | +-----------------------+-----------------------+-----------------------+ | 'BlockTag'            | 'BlockTagContent'     | —                     | +-----------------------+-----------------------+-----------------------++| 'TaggedPlainBlock'    | 'PlainBlock'          | 'Fragment'            |++-----------------------+-----------------------+-----------------------++| 'PlainBlock'          | —                     | 'Fragment'            |++-----------------------+-----------------------+-----------------------+ | 'Paragraph'           | 'Lines'               | 'Line'                | +-----------------------+-----------------------+-----------------------++| 'TaggedLines'         | 'Lines'               | 'Line'                |++-----------------------+-----------------------+-----------------------+ | 'Lines'               | —                     | 'Line'                | +-----------------------+-----------------------+-----------------------+ | 'Line'                | —                     | 'Inline'              | +-----------------------+-----------------------+-----------------------+-| 'PlainBlock'          | —                     | 'Fragment'            |-+-----------------------+-----------------------+-----------------------+-| 'Tagged' y            | y                     | 'Contents' y          |-+-----------------------+-----------------------+-----------------------+ | 'Fragment'            | 'Text'                | —                     | +-----------------------+-----------------------+-----------------------+ @@ -175,7 +175,7 @@ +-----------------------+-----------------------+-----------------------+ | 'Block'               | 'BlockTag'            | 'Paragraph'           | +-----------------------+-----------------------+-----------------------+-| 'Inline'              | 'Tagged' 'Lines'      | 'Fragment'            |+| 'Inline'              | 'TaggedLines'         | 'Fragment'            | +-----------------------+-----------------------+-----------------------+  @@ -189,13 +189,17 @@  List of nodes and their fork/plain types: -+-----------------------+-----------------------+-----------------------+-| __x__                 | __Fork x__            | __Plain x__           |-+-----------------------+-----------------------+-----------------------+-| 'Block'               | 'Tagged' 'Blocks'     | 'Tagged' 'PlainBlock' |-+-----------------------+-----------------------+-----------------------+-| 'Inline'              | 'Tagged' 'Lines'      | 'Fragment'            |-+-----------------------+-----------------------+-----------------------+++-----------------------+--------------------+-----------------------++| __x__                 | __Fork x__         | __Plain x__           |++-----------------------+--------------------+-----------------------++| 'Block'               | 'TaggedBlocks'     | 'TaggedPlainBlock'    |++-----------------------+--------------------+-----------------------++| 'BlockTag'            | 'TaggedBlocks'     | 'TaggedPlainBlock'    |++-----------------------+--------------------+-----------------------++| 'BlockTagContent'     | 'Blocks'           | 'PlainBlock'          |++-----------------------+--------------------+-----------------------++| 'Inline'              | 'TaggedLines'      | 'Fragment'            |++-----------------------+--------------------+-----------------------+  ('Block' also has a third prism, 'bare', which is neither fork nor plain.) @@ -236,15 +240,15 @@     (     {- * Document -} Document (..), -    {- * Blocks -} Block (..), Blocks (..),+    {- * Blocks -} Block (..), Blocks (..), TaggedBlocks (..),     {- ** Paragraphs -} Paragraph (..), HasManyParagraphs (..),     {- ** Tag blocks -} BlockTag (..), BlockTagContent (..), -    {- * Lines -} Inline (..), Line (..), Lines (..),-    {- ** Plain text -} Fragment (..), PlainBlock (..),+    {- * Lines -} Inline (..), Line (..), Lines (..), TaggedLines (..),+    {- ** Plain text -} Fragment (..), PlainBlock (..), TaggedPlainBlock (..),             HasManyPlainInlines (..), HasManyPlainBlocks (..), -    {- * Tags -} Tag (..), Tagged (..), name, HasTag (..),+    {- * Tags -} Tag (..), name, HasTag (..),     {- ** Traversal -} HasManyTags (..), HasManyBlockTags (..),     {- ** Withering -} HasWitherableTags (..),             HasWitherableInlineTags (..), HasWitherableBlockTags (..),

@@ -10,7 +10,8 @@     , Inline (..), Line (..), Lines (..)      -- * Tags and tagged things-    , Tag (..), Tagged (..), BlockTag (..), TaggedOrBare (..)+    , Tag (..), BlockTag (..), TaggedBlocks (..)+    , TaggedPlainBlock (..), TaggedLines (..), TaggedOrBare (..)      -- * Paragraph     , Paragraph (..)

@@ -3,9 +3,6 @@     -- * Annotation       Annotation -    -- * Content plus a tag-    , Tagged-     -- ** Content     , Content, Contents 

@@ -4,16 +4,15 @@       Document (..)      -- * Blocks-    , Block (..), Blocks (..), BlockTag (..), BlockTagContent (..)+    , Block (..), Blocks (..), BlockTag (..)+    , TaggedBlocks (..), BlockTagContent (..)+    , TaggedPlainBlock (..)      -- * Paragraph     , Paragraph (..)      -- * Inlines-    , Inline (..), Line (..), Lines (..)--    -- * Tagged-    , Tagged (..)+    , Inline (..), Line (..), Lines (..), TaggedLines (..)      -- * Text     , PlainBlock (..), Fragment (..)

@@ -1,5 +1,5 @@ module ProAbstract.Structure.Block-    ( Block (..), paragraph, Blocks (..), Tagged (..)+    ( Block (..), paragraph, Blocks (..), TaggedBlocks (..)     ) where  import ProAbstract.Annotation@@ -20,17 +20,17 @@ -- ⭐ Block  data Block ann =-    BlockPlain     (Tagged (PlainBlock ann)) -- ^ 'ProAbstract.plain'-  | BlockParagraph (Paragraph ann)           -- ^ 'ProAbstract.bare'-  | BlockFork      (Tagged (Blocks ann))     -- ^ 'ProAbstract.fork'+    BlockPlain     (TaggedPlainBlock ann)  -- ^ 'ProAbstract.plain'+  | BlockParagraph (Paragraph ann)         -- ^ 'ProAbstract.bare'+  | BlockFork      (TaggedBlocks ann)      -- ^ 'ProAbstract.fork'   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData)  type instance Annotation (Block ann) = ann -type instance Plain (Block ann) = Tagged (PlainBlock ann)+type instance Plain (Block ann) = TaggedPlainBlock ann -type instance Fork (Block ann) = Tagged (Blocks ann)+type instance Fork (Block ann) = TaggedBlocks ann  instance HasMetadata (Block ann) where     type MetadataOpticKind (Block ann) = An_AffineTraversal@@ -177,9 +177,9 @@     witherInlineTags f = traverseOf (contents % traversed) (witherInlineTags f)  --- ⭐ Tagged Blocks+-- ⭐ TaggedBlocks -data instance Tagged (Blocks ann) =+data TaggedBlocks ann =   TaggedBlocks     { blocksTag :: Tag ann -- ^ 'ProAbstract.tag'     , taggedBlocks :: Blocks ann -- ^ 'ProAbstract.content'@@ -187,51 +187,51 @@   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData) -type instance Annotation (Tagged (Blocks ann)) = ann+type instance Annotation (TaggedBlocks ann) = ann -instance HasTag (Tagged (Blocks ann)) where-    type TagOpticKind (Tagged (Blocks ann)) = A_Lens+instance HasTag (TaggedBlocks ann) where+    type TagOpticKind (TaggedBlocks ann) = A_Lens     tag = lens blocksTag \x a -> x{ blocksTag = a } -type instance Content (Tagged (Blocks ann)) = Blocks ann+type instance Content (TaggedBlocks ann) = Blocks ann -type instance Contents (Tagged (Blocks ann)) = Block ann+type instance Contents (TaggedBlocks ann) = Block ann -instance HasManyAnnotations (Tagged (Blocks ann)) (Tagged (Blocks ann')) where+instance HasManyAnnotations (TaggedBlocks ann) (TaggedBlocks ann') where     allAnnotations = traversalVL \f (TaggedBlocks t b) -> TaggedBlocks         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b -instance HasAnnotation (Tagged (Blocks ann)) (Tagged (Blocks ann)) where+instance HasAnnotation (TaggedBlocks ann) (TaggedBlocks ann) where      annotation = tag % annotation -instance HasContent (Tagged (Blocks ann)) (Tagged (Blocks ann)) where+instance HasContent (TaggedBlocks ann) (TaggedBlocks ann) where     content = lens taggedBlocks \x c -> x{ taggedBlocks = c } -instance HasContents (Tagged (Blocks ann)) (Tagged (Blocks ann)) where+instance HasContents (TaggedBlocks ann) (TaggedBlocks ann) where     contents = content % contents -instance HasMetadata (Tagged (Blocks ann)) where-    type MetadataOpticKind (Tagged (Blocks ann)) = A_Lens+instance HasMetadata (TaggedBlocks ann) where+    type MetadataOpticKind (TaggedBlocks ann) = A_Lens     metadata = tag % metadata -instance HasManyPlainInlines (Tagged (Blocks ann)) where+instance HasManyPlainInlines (TaggedBlocks ann) where     allPlainInlines = content % allPlainInlines -instance HasManyTags (Tagged (Blocks ann)) where+instance HasManyTags (TaggedBlocks ann) where     allTags = tag `adjoin` (content % allTags)     allInlineTags = allParagraphs % allInlineTags -instance HasManyBlockTags (Tagged (Blocks ann)) where+instance HasManyBlockTags (TaggedBlocks ann) where     allBlockTags = tag `adjoin` (content % allBlockTags) -instance HasWitherableInlineTags (Tagged (Blocks ann)) where+instance HasWitherableInlineTags (TaggedBlocks ann) where     witherInlineTags f = traverseOf allParagraphs (witherInlineTags f) -instance HasManyMetadata (Tagged (Blocks ann)) where+instance HasManyMetadata (TaggedBlocks ann) where     allMetadata = allTags % metadata -instance HasManyParagraphs (Tagged (Blocks ann)) where+instance HasManyParagraphs (TaggedBlocks ann) where     allParagraphs = content % allParagraphs -instance HasManyPlainBlocks (Tagged (Blocks ann)) where+instance HasManyPlainBlocks (TaggedBlocks ann) where     allPlainBlocks = content % allPlainBlocks

@@ -18,8 +18,8 @@ import ProAbstract.Tag  data BlockTag ann =-    BlockTagFork  (Tagged (Blocks ann))     -- ^ 'ProAbstract.fork'-  | BlockTagPlain (Tagged (PlainBlock ann)) -- ^ 'ProAbstract.plain'+    BlockTagFork  (TaggedBlocks ann)     -- ^ 'ProAbstract.fork'+  | BlockTagPlain (TaggedPlainBlock ann) -- ^ 'ProAbstract.plain'   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData) @@ -27,9 +27,9 @@  type instance Annotation (BlockTag ann) = ann -type instance Plain (BlockTag ann) = Tagged (PlainBlock ann)+type instance Plain (BlockTag ann) = TaggedPlainBlock ann -type instance Fork (BlockTag ann) = Tagged (Blocks ann)+type instance Fork (BlockTag ann) = TaggedBlocks ann  instance HasContent (BlockTag ann) (BlockTag ann) where     content = lens f g

@@ -6,4 +6,4 @@ import ProAbstract.Structure.PlainBlock  class HasManyPlainBlocks x where-    allPlainBlocks :: Traversal' x (Tagged (PlainBlock (Annotation x)))+    allPlainBlocks :: Traversal' x (TaggedPlainBlock (Annotation x))

@@ -1,5 +1,5 @@ module ProAbstract.Structure.Inline-    ( Inline (..), Line (..), Lines (..), Tagged (..)+    ( Inline (..), Line (..), Lines (..), TaggedLines (..)     ) where  import ProAbstract.Annotation@@ -17,14 +17,14 @@ -- ⭐ Inline  data Inline ann =-    InlineFork (Tagged (Lines ann)) -- ^ 'ProAbstract.fork'+    InlineFork (TaggedLines ann) -- ^ 'ProAbstract.fork'   | InlinePlain (Fragment ann) -- ^ 'ProAbstract.plain'   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData)  type instance Annotation (Inline ann) = ann -type instance Fork (Inline ann) = Tagged (Lines ann)+type instance Fork (Inline ann) = TaggedLines ann  type instance Plain (Inline ann) = Fragment ann @@ -166,9 +166,9 @@     witherTags f = traverseOf (contents % traversed) (witherTags f)  --- ⭐ Tagged Lines+-- ⭐ TaggedLines -data instance Tagged (Lines ann) =+data TaggedLines ann =   TaggedLines     { linesTag :: Tag ann -- ^ 'ProAbstract.tag'     , taggedLines :: Lines ann -- ^ 'ProAbstract.content'@@ -176,42 +176,42 @@   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData) -type instance Annotation (Tagged (Lines ann)) = ann+type instance Annotation (TaggedLines ann) = ann -instance HasTag (Tagged (Lines ann)) where-    type TagOpticKind (Tagged (Lines ann)) = A_Lens+instance HasTag (TaggedLines ann) where+    type TagOpticKind (TaggedLines ann) = A_Lens     tag = lens linesTag \x a -> x{ linesTag = a } -type instance Content (Tagged (Lines ann)) = Lines ann+type instance Content (TaggedLines ann) = Lines ann -type instance Contents (Tagged (Lines ann)) = Line ann+type instance Contents (TaggedLines ann) = Line ann -instance HasManyAnnotations (Tagged (Lines ann)) (Tagged (Lines ann')) where+instance HasManyAnnotations (TaggedLines ann) (TaggedLines ann') where     allAnnotations = traversalVL \f (TaggedLines t b) -> TaggedLines         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b -instance HasAnnotation (Tagged (Lines ann)) (Tagged (Lines ann)) where+instance HasAnnotation (TaggedLines ann) (TaggedLines ann) where      annotation = tag % annotation -instance HasContent (Tagged (Lines ann)) (Tagged (Lines ann)) where+instance HasContent (TaggedLines ann) (TaggedLines ann) where     content = lens taggedLines \x c -> x{ taggedLines = c } -instance HasContents (Tagged (Lines ann)) (Tagged (Lines ann)) where+instance HasContents (TaggedLines ann) (TaggedLines ann) where     contents = content % contents -instance HasMetadata (Tagged (Lines ann)) where-    type MetadataOpticKind (Tagged (Lines ann)) = A_Lens+instance HasMetadata (TaggedLines ann) where+    type MetadataOpticKind (TaggedLines ann) = A_Lens     metadata = tag % metadata -instance HasManyPlainInlines (Tagged (Lines ann)) where+instance HasManyPlainInlines (TaggedLines ann) where     allPlainInlines = content % allPlainInlines -instance HasManyTags (Tagged (Lines ann)) where+instance HasManyTags (TaggedLines ann) where     allTags = tag `adjoin` (content % allTags)     allInlineTags = allTags -instance HasWitherableInlineTags (Tagged (Lines ann)) where+instance HasWitherableInlineTags (TaggedLines ann) where     witherInlineTags f = traverseOf content (witherInlineTags f) -instance HasManyMetadata (Tagged (Lines ann)) where+instance HasManyMetadata (TaggedLines ann) where    allMetadata = allTags % metadata

@@ -49,7 +49,7 @@  instance IsTaggedOrBare (Inline ann) where -    type TaggedType (Inline ann) = Tagged (Lines ann)+    type TaggedType (Inline ann) = TaggedLines ann     type BareType (Inline ann) = Fragment ann      taggedOrBare = iso f g

@@ -1,5 +1,5 @@ module ProAbstract.Structure.PlainBlock-    ( PlainBlock (..), Tagged (..)+    ( PlainBlock (..), TaggedPlainBlock (..)     ) where  import ProAbstract.Annotation@@ -33,9 +33,9 @@         PlainBlock <$> traverseOf (traversed % annotation) f t <*> f a  --- ⭐ Tagged PlainBlock+-- ⭐ TaggedPlainBlock -data instance Tagged (PlainBlock ann) =+data TaggedPlainBlock ann =   TaggedPlainBlock     { plaintextTag :: Tag ann -- ^ 'ProAbstract.Tag'     , taggedPlaintext :: PlainBlock ann -- ^ 'ProAbstract.content'@@ -43,29 +43,29 @@   deriving stock (Eq, Show, Generic)   deriving anyclass (Hashable, NFData) -type instance Annotation (Tagged (PlainBlock ann)) = ann+type instance Annotation (TaggedPlainBlock ann) = ann -instance HasTag (Tagged (PlainBlock ann)) where-    type TagOpticKind (Tagged (PlainBlock ann)) = A_Lens+instance HasTag (TaggedPlainBlock ann) where+    type TagOpticKind (TaggedPlainBlock ann) = A_Lens     tag = lens plaintextTag \x a -> x{ plaintextTag = a } -type instance Content (Tagged (PlainBlock ann)) = PlainBlock ann+type instance Content (TaggedPlainBlock ann) = PlainBlock ann -type instance Contents (Tagged (PlainBlock ann)) = Fragment ann+type instance Contents (TaggedPlainBlock ann) = Fragment ann -instance HasContents (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where+instance HasContents (TaggedPlainBlock ann) (TaggedPlainBlock ann) where     contents = content % contents -instance HasManyAnnotations (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann')) where+instance HasManyAnnotations (TaggedPlainBlock ann) (TaggedPlainBlock ann') where     allAnnotations = traversalVL \f (TaggedPlainBlock t b) -> TaggedPlainBlock         <$> traverseOf annotation f t <*> traverseOf allAnnotations f b -instance HasAnnotation (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where+instance HasAnnotation (TaggedPlainBlock ann) (TaggedPlainBlock ann) where      annotation = tag % annotation -instance HasContent (Tagged (PlainBlock ann)) (Tagged (PlainBlock ann)) where+instance HasContent (TaggedPlainBlock ann) (TaggedPlainBlock ann) where     content = lens taggedPlaintext \x c -> x{ taggedPlaintext = c } -instance HasMetadata (Tagged (PlainBlock ann)) where-    type MetadataOpticKind (Tagged (PlainBlock ann)) = A_Lens+instance HasMetadata (TaggedPlainBlock ann) where+    type MetadataOpticKind (TaggedPlainBlock ann) = A_Lens     metadata = tag % metadata

@@ -1,6 +1,5 @@ module ProAbstract.Tag     ( Tag (..), name-    , Tagged     , HasTag (..)     , HasManyTags (..), HasWitherableTags (..)     , HasManyBlockTags (..), HasWitherableBlockTags (..)@@ -11,4 +10,3 @@ import ProAbstract.Tag.HasTag import ProAbstract.Tag.HasTagOptics import ProAbstract.Tag.TagType-import ProAbstract.Tag.TaggedFamily

@@ -1,5 +0,0 @@-module ProAbstract.Tag.TaggedFamily-    ( Tagged-    ) where--data family Tagged con

@@ -17,8 +17,8 @@  instance CanHaveTaglessContent (BlockTag ann) where     taglessContent s =-        (plain % taglessContent @(Tagged (PlainBlock ann)) s) `afailing`-        (fork % taglessContent @(Tagged (Blocks ann)) s)+        (plain % taglessContent @(TaggedPlainBlock ann) s) `afailing`+        (fork % taglessContent @(TaggedBlocks ann) s)  instance CanHaveTaglessContent (BlockTagContent ann) where     taglessContent = tagless@@ -40,13 +40,13 @@ instance CanHaveTaglessContent (Fragment ann) where     taglessContent = tagless -instance CanHaveTaglessContent (Tagged (Blocks ann)) where+instance CanHaveTaglessContent (TaggedBlocks ann) where     taglessContent s = content % tagless s -instance CanHaveTaglessContent (Tagged (PlainBlock ann)) where+instance CanHaveTaglessContent (TaggedPlainBlock ann) where     taglessContent s = content % tagless s -instance CanHaveTaglessContent (Tagged (Lines ann)) where+instance CanHaveTaglessContent (TaggedLines ann) where     taglessContent s = content % tagless s  instance CanHaveTaglessContent (Document ann) where

@@ -12,19 +12,17 @@     , Inline     , Line     , Lines-    , Map     , MetaItem     , MetaValue     , Metadata     , Paragraph     , Plain     , PlainBlock-    , Seq-    , Set     , Tag-    , Tagged+    , TaggedBlocks+    , TaggedLines+    , TaggedPlainBlock     , TaggedOrBare-    , Text     ) where  import ProAbstract.Datatypes

@@ -1,7 +1,7 @@ cabal-version: 3.0  name: pro-abstract-version: 0.2.1.0+version: 0.3.0.0  category: Language synopsis: Abstract syntax for writing documents@@ -110,7 +110,6 @@       , ProAbstract.Tag.HasManyTags       , ProAbstract.Tag.HasTag       , ProAbstract.Tag.HasTagOptics-      , ProAbstract.Tag.TaggedFamily       , ProAbstract.Tag.TagOptics       , ProAbstract.Tag.TagType       , ProAbstract.Tagless.CanBeTagless