-- | For background info on the spec, see the "Incremental lists" section of the
-- the pandoc manual.
{-# LANGUAGE CPP               #-}
{-# LANGUAGE DeriveFoldable    #-}
{-# LANGUAGE DeriveFunctor     #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE OverloadedStrings #-}
module Patat.Presentation.Fragment
    ( FragmentSettings (..)
    , fragmentBlocks
    , fragmentBlock
    ) where

import           Data.List   (foldl', intersperse)
import           Data.Maybe  (fromMaybe)
import           Prelude
import qualified Text.Pandoc as Pandoc

data FragmentSettings = FragmentSettings
    { FragmentSettings -> Bool
fsIncrementalLists :: !Bool
    } deriving (Int -> FragmentSettings -> ShowS
[FragmentSettings] -> ShowS
FragmentSettings -> String
(Int -> FragmentSettings -> ShowS)
-> (FragmentSettings -> String)
-> ([FragmentSettings] -> ShowS)
-> Show FragmentSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FragmentSettings] -> ShowS
$cshowList :: [FragmentSettings] -> ShowS
show :: FragmentSettings -> String
$cshow :: FragmentSettings -> String
showsPrec :: Int -> FragmentSettings -> ShowS
$cshowsPrec :: Int -> FragmentSettings -> ShowS
Show)

-- fragmentBlocks :: [Pandoc.Block] -> [[Pandoc.Block]]
-- fragmentBlocks = NonEmpty.toList . joinFragmentedBlocks . map fragmentBlock
fragmentBlocks :: FragmentSettings -> [Pandoc.Block] -> [[Pandoc.Block]]
fragmentBlocks :: FragmentSettings -> [Block] -> [[Block]]
fragmentBlocks fs :: FragmentSettings
fs blocks0 :: [Block]
blocks0 =
    case [Fragmented Block] -> Fragmented [Block]
forall block. [Fragmented block] -> Fragmented [block]
joinFragmentedBlocks ((Block -> Fragmented Block) -> [Block] -> [Fragmented Block]
forall a b. (a -> b) -> [a] -> [b]
map (FragmentSettings -> Block -> Fragmented Block
fragmentBlock FragmentSettings
fs) [Block]
blocks0) of
        Unfragmented  bs :: [Block]
bs -> [[Block]
bs]
        Fragmented xs :: [Maybe [Block]]
xs bs :: Maybe [Block]
bs -> (Maybe [Block] -> [Block]) -> [Maybe [Block]] -> [[Block]]
forall a b. (a -> b) -> [a] -> [b]
map ([Block] -> Maybe [Block] -> [Block]
forall a. a -> Maybe a -> a
fromMaybe []) [Maybe [Block]]
xs [[Block]] -> [[Block]] -> [[Block]]
forall a. [a] -> [a] -> [a]
++ [[Block] -> Maybe [Block] -> [Block]
forall a. a -> Maybe a -> a
fromMaybe [] Maybe [Block]
bs]

-- | This is all the ways we can "present" a block, after splitting in
-- fragments.
--
-- In the simplest (and most common case) a block can only be presented in a
-- single way ('Unfragmented').
--
-- Alternatively, we might want to show different (partial) versions of the
-- block first before showing the final complete one.  These partial or complete
-- versions can be empty, hence the 'Maybe'.
--
-- For example, imagine that we display the following bullet list incrementally:
--
-- > [1, 2, 3]
--
-- Then we would get something like:
--
-- > Fragmented [Nothing, Just [1], Just [1, 2]] (Just [1, 2, 3])
data Fragmented a
    = Unfragmented a
    | Fragmented [Maybe a] (Maybe a)
    deriving (a -> Fragmented b -> Fragmented a
(a -> b) -> Fragmented a -> Fragmented b
(forall a b. (a -> b) -> Fragmented a -> Fragmented b)
-> (forall a b. a -> Fragmented b -> Fragmented a)
-> Functor Fragmented
forall a b. a -> Fragmented b -> Fragmented a
forall a b. (a -> b) -> Fragmented a -> Fragmented b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Fragmented b -> Fragmented a
$c<$ :: forall a b. a -> Fragmented b -> Fragmented a
fmap :: (a -> b) -> Fragmented a -> Fragmented b
$cfmap :: forall a b. (a -> b) -> Fragmented a -> Fragmented b
Functor, Fragmented a -> Bool
(a -> m) -> Fragmented a -> m
(a -> b -> b) -> b -> Fragmented a -> b
(forall m. Monoid m => Fragmented m -> m)
-> (forall m a. Monoid m => (a -> m) -> Fragmented a -> m)
-> (forall m a. Monoid m => (a -> m) -> Fragmented a -> m)
-> (forall a b. (a -> b -> b) -> b -> Fragmented a -> b)
-> (forall a b. (a -> b -> b) -> b -> Fragmented a -> b)
-> (forall b a. (b -> a -> b) -> b -> Fragmented a -> b)
-> (forall b a. (b -> a -> b) -> b -> Fragmented a -> b)
-> (forall a. (a -> a -> a) -> Fragmented a -> a)
-> (forall a. (a -> a -> a) -> Fragmented a -> a)
-> (forall a. Fragmented a -> [a])
-> (forall a. Fragmented a -> Bool)
-> (forall a. Fragmented a -> Int)
-> (forall a. Eq a => a -> Fragmented a -> Bool)
-> (forall a. Ord a => Fragmented a -> a)
-> (forall a. Ord a => Fragmented a -> a)
-> (forall a. Num a => Fragmented a -> a)
-> (forall a. Num a => Fragmented a -> a)
-> Foldable Fragmented
forall a. Eq a => a -> Fragmented a -> Bool
forall a. Num a => Fragmented a -> a
forall a. Ord a => Fragmented a -> a
forall m. Monoid m => Fragmented m -> m
forall a. Fragmented a -> Bool
forall a. Fragmented a -> Int
forall a. Fragmented a -> [a]
forall a. (a -> a -> a) -> Fragmented a -> a
forall m a. Monoid m => (a -> m) -> Fragmented a -> m
forall b a. (b -> a -> b) -> b -> Fragmented a -> b
forall a b. (a -> b -> b) -> b -> Fragmented 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 :: Fragmented a -> a
$cproduct :: forall a. Num a => Fragmented a -> a
sum :: Fragmented a -> a
$csum :: forall a. Num a => Fragmented a -> a
minimum :: Fragmented a -> a
$cminimum :: forall a. Ord a => Fragmented a -> a
maximum :: Fragmented a -> a
$cmaximum :: forall a. Ord a => Fragmented a -> a
elem :: a -> Fragmented a -> Bool
$celem :: forall a. Eq a => a -> Fragmented a -> Bool
length :: Fragmented a -> Int
$clength :: forall a. Fragmented a -> Int
null :: Fragmented a -> Bool
$cnull :: forall a. Fragmented a -> Bool
toList :: Fragmented a -> [a]
$ctoList :: forall a. Fragmented a -> [a]
foldl1 :: (a -> a -> a) -> Fragmented a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Fragmented a -> a
foldr1 :: (a -> a -> a) -> Fragmented a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Fragmented a -> a
foldl' :: (b -> a -> b) -> b -> Fragmented a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Fragmented a -> b
foldl :: (b -> a -> b) -> b -> Fragmented a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Fragmented a -> b
foldr' :: (a -> b -> b) -> b -> Fragmented a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Fragmented a -> b
foldr :: (a -> b -> b) -> b -> Fragmented a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Fragmented a -> b
foldMap' :: (a -> m) -> Fragmented a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Fragmented a -> m
foldMap :: (a -> m) -> Fragmented a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Fragmented a -> m
fold :: Fragmented m -> m
$cfold :: forall m. Monoid m => Fragmented m -> m
Foldable, Int -> Fragmented a -> ShowS
[Fragmented a] -> ShowS
Fragmented a -> String
(Int -> Fragmented a -> ShowS)
-> (Fragmented a -> String)
-> ([Fragmented a] -> ShowS)
-> Show (Fragmented a)
forall a. Show a => Int -> Fragmented a -> ShowS
forall a. Show a => [Fragmented a] -> ShowS
forall a. Show a => Fragmented a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fragmented a] -> ShowS
$cshowList :: forall a. Show a => [Fragmented a] -> ShowS
show :: Fragmented a -> String
$cshow :: forall a. Show a => Fragmented a -> String
showsPrec :: Int -> Fragmented a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Fragmented a -> ShowS
Show, Functor Fragmented
Foldable Fragmented
(Functor Fragmented, Foldable Fragmented) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Fragmented a -> f (Fragmented b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Fragmented (f a) -> f (Fragmented a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Fragmented a -> m (Fragmented b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Fragmented (m a) -> m (Fragmented a))
-> Traversable Fragmented
(a -> f b) -> Fragmented a -> f (Fragmented 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 =>
Fragmented (m a) -> m (Fragmented a)
forall (f :: * -> *) a.
Applicative f =>
Fragmented (f a) -> f (Fragmented a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Fragmented a -> m (Fragmented b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Fragmented a -> f (Fragmented b)
sequence :: Fragmented (m a) -> m (Fragmented a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Fragmented (m a) -> m (Fragmented a)
mapM :: (a -> m b) -> Fragmented a -> m (Fragmented b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Fragmented a -> m (Fragmented b)
sequenceA :: Fragmented (f a) -> f (Fragmented a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Fragmented (f a) -> f (Fragmented a)
traverse :: (a -> f b) -> Fragmented a -> f (Fragmented b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Fragmented a -> f (Fragmented b)
$cp2Traversable :: Foldable Fragmented
$cp1Traversable :: Functor Fragmented
Traversable)

fragmentBlock :: FragmentSettings -> Pandoc.Block -> Fragmented Pandoc.Block
fragmentBlock :: FragmentSettings -> Block -> Fragmented Block
fragmentBlock _fs :: FragmentSettings
_fs block :: Block
block@(Pandoc.Para inlines :: [Inline]
inlines)
    | [Inline]
inlines [Inline] -> [Inline] -> Bool
forall a. Eq a => a -> a -> Bool
== [Inline]
threeDots = [Maybe Block] -> Maybe Block -> Fragmented Block
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented [Maybe Block
forall a. Maybe a
Nothing] Maybe Block
forall a. Maybe a
Nothing
    | Bool
otherwise            = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
  where
    threeDots :: [Inline]
threeDots = Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
intersperse Inline
Pandoc.Space ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. (a -> b) -> a -> b
$ Int -> Inline -> [Inline]
forall a. Int -> a -> [a]
replicate 3 (Text -> Inline
Pandoc.Str ".")

fragmentBlock fs :: FragmentSettings
fs (Pandoc.BulletList bs0 :: [[Block]]
bs0) =
    FragmentSettings
-> Bool -> ([[Block]] -> Block) -> [[Block]] -> Fragmented Block
fragmentList FragmentSettings
fs (FragmentSettings -> Bool
fsIncrementalLists FragmentSettings
fs) [[Block]] -> Block
Pandoc.BulletList [[Block]]
bs0

fragmentBlock fs :: FragmentSettings
fs (Pandoc.OrderedList attr :: ListAttributes
attr bs0 :: [[Block]]
bs0) =
    FragmentSettings
-> Bool -> ([[Block]] -> Block) -> [[Block]] -> Fragmented Block
fragmentList FragmentSettings
fs (FragmentSettings -> Bool
fsIncrementalLists FragmentSettings
fs) (ListAttributes -> [[Block]] -> Block
Pandoc.OrderedList ListAttributes
attr) [[Block]]
bs0

fragmentBlock fs :: FragmentSettings
fs (Pandoc.BlockQuote [Pandoc.BulletList bs0 :: [[Block]]
bs0]) =
    FragmentSettings
-> Bool -> ([[Block]] -> Block) -> [[Block]] -> Fragmented Block
fragmentList FragmentSettings
fs (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FragmentSettings -> Bool
fsIncrementalLists FragmentSettings
fs) [[Block]] -> Block
Pandoc.BulletList [[Block]]
bs0

fragmentBlock fs :: FragmentSettings
fs (Pandoc.BlockQuote [Pandoc.OrderedList attr :: ListAttributes
attr bs0 :: [[Block]]
bs0]) =
    FragmentSettings
-> Bool -> ([[Block]] -> Block) -> [[Block]] -> Fragmented Block
fragmentList FragmentSettings
fs (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ FragmentSettings -> Bool
fsIncrementalLists FragmentSettings
fs) (ListAttributes -> [[Block]] -> Block
Pandoc.OrderedList ListAttributes
attr) [[Block]]
bs0

fragmentBlock _ block :: Block
block@(Pandoc.BlockQuote _)     = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block

fragmentBlock _ block :: Block
block@(Pandoc.Header _ _ _)     = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.Plain _)          = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.CodeBlock _ _)    = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.RawBlock _ _)     = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.DefinitionList _) = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.Table _ _ _ _ _)  = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@(Pandoc.Div _ _)          = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@Block
Pandoc.HorizontalRule     = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
fragmentBlock _ block :: Block
block@Block
Pandoc.Null               = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block

#if MIN_VERSION_pandoc(1,18,0)
fragmentBlock _ block :: Block
block@(Pandoc.LineBlock _)      = Block -> Fragmented Block
forall a. a -> Fragmented a
Unfragmented Block
block
#endif

joinFragmentedBlocks :: [Fragmented block] -> Fragmented [block]
joinFragmentedBlocks :: [Fragmented block] -> Fragmented [block]
joinFragmentedBlocks =
    (Fragmented [block] -> Fragmented block -> Fragmented [block])
-> Fragmented [block] -> [Fragmented block] -> Fragmented [block]
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Fragmented [block] -> Fragmented block -> Fragmented [block]
forall a. Fragmented [a] -> Fragmented a -> Fragmented [a]
append ([block] -> Fragmented [block]
forall a. a -> Fragmented a
Unfragmented [])
  where
    append :: Fragmented [a] -> Fragmented a -> Fragmented [a]
append (Unfragmented xs :: [a]
xs) (Unfragmented y :: a
y) =
        [a] -> Fragmented [a]
forall a. a -> Fragmented a
Unfragmented ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a
y])

    append (Fragmented xs :: [Maybe [a]]
xs x :: Maybe [a]
x) (Unfragmented y :: a
y) =
        [Maybe [a]] -> Maybe [a] -> Fragmented [a]
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented [Maybe [a]]
xs (Maybe [a] -> Maybe a -> Maybe [a]
forall a. Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe Maybe [a]
x (a -> Maybe a
forall a. a -> Maybe a
Just a
y))

    append (Unfragmented x :: [a]
x) (Fragmented ys :: [Maybe a]
ys y :: Maybe a
y) =
        [Maybe [a]] -> Maybe [a] -> Fragmented [a]
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented
            [Maybe [a] -> Maybe a -> Maybe [a]
forall a. Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe ([a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
x) Maybe a
y' | Maybe a
y' <- [Maybe a]
ys]
            (Maybe [a] -> Maybe a -> Maybe [a]
forall a. Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe ([a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
x) Maybe a
y)

    append (Fragmented xs :: [Maybe [a]]
xs x :: Maybe [a]
x) (Fragmented ys :: [Maybe a]
ys y :: Maybe a
y) =
        [Maybe [a]] -> Maybe [a] -> Fragmented [a]
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented
            ([Maybe [a]]
xs [Maybe [a]] -> [Maybe [a]] -> [Maybe [a]]
forall a. [a] -> [a] -> [a]
++ [Maybe [a] -> Maybe a -> Maybe [a]
forall a. Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe Maybe [a]
x Maybe a
y' | Maybe a
y' <- [Maybe a]
ys])
            (Maybe [a] -> Maybe a -> Maybe [a]
forall a. Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe Maybe [a]
x Maybe a
y)

    appendMaybe :: Maybe [a] -> Maybe a -> Maybe [a]
    appendMaybe :: Maybe [a] -> Maybe a -> Maybe [a]
appendMaybe Nothing   Nothing  = Maybe [a]
forall a. Maybe a
Nothing
    appendMaybe Nothing   (Just x :: a
x) = [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a
x]
    appendMaybe (Just xs :: [a]
xs) Nothing  = [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
xs
    appendMaybe (Just xs :: [a]
xs) (Just x :: a
x) = [a] -> Maybe [a]
forall a. a -> Maybe a
Just ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a
x])

fragmentList
    :: FragmentSettings                    -- ^ Global settings
    -> Bool                                -- ^ Fragment THIS list?
    -> ([[Pandoc.Block]] -> Pandoc.Block)  -- ^ List constructor
    -> [[Pandoc.Block]]                    -- ^ List items
    -> Fragmented Pandoc.Block             -- ^ Resulting list
fragmentList :: FragmentSettings
-> Bool -> ([[Block]] -> Block) -> [[Block]] -> Fragmented Block
fragmentList fs :: FragmentSettings
fs fragmentThisList :: Bool
fragmentThisList constructor :: [[Block]] -> Block
constructor blocks0 :: [[Block]]
blocks0 =
    ([[Block]] -> Block) -> Fragmented [[Block]] -> Fragmented Block
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[Block]] -> Block
constructor Fragmented [[Block]]
fragmented
  where
    -- The fragmented list per list item.
    items :: [Fragmented [Pandoc.Block]]
    items :: [Fragmented [Block]]
items = ([Block] -> Fragmented [Block])
-> [[Block]] -> [Fragmented [Block]]
forall a b. (a -> b) -> [a] -> [b]
map ([Fragmented Block] -> Fragmented [Block]
forall block. [Fragmented block] -> Fragmented [block]
joinFragmentedBlocks ([Fragmented Block] -> Fragmented [Block])
-> ([Block] -> [Fragmented Block]) -> [Block] -> Fragmented [Block]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Block -> Fragmented Block) -> [Block] -> [Fragmented Block]
forall a b. (a -> b) -> [a] -> [b]
map (FragmentSettings -> Block -> Fragmented Block
fragmentBlock FragmentSettings
fs)) [[Block]]
blocks0

    fragmented :: Fragmented [[Pandoc.Block]]
    fragmented :: Fragmented [[Block]]
fragmented = [Fragmented [Block]] -> Fragmented [[Block]]
forall block. [Fragmented block] -> Fragmented [block]
joinFragmentedBlocks ([Fragmented [Block]] -> Fragmented [[Block]])
-> [Fragmented [Block]] -> Fragmented [[Block]]
forall a b. (a -> b) -> a -> b
$
        (Fragmented [Block] -> Fragmented [Block])
-> [Fragmented [Block]] -> [Fragmented [Block]]
forall a b. (a -> b) -> [a] -> [b]
map (if Bool
fragmentThisList then Fragmented [Block] -> Fragmented [Block]
forall a. Fragmented a -> Fragmented a
insertPause else Fragmented [Block] -> Fragmented [Block]
forall a. a -> a
id) [Fragmented [Block]]
items

    insertPause :: Fragmented a -> Fragmented a
    insertPause :: Fragmented a -> Fragmented a
insertPause (Unfragmented x :: a
x)  = [Maybe a] -> Maybe a -> Fragmented a
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented [Maybe a
forall a. Maybe a
Nothing] (a -> Maybe a
forall a. a -> Maybe a
Just a
x)
    insertPause (Fragmented xs :: [Maybe a]
xs x :: Maybe a
x) = [Maybe a] -> Maybe a -> Fragmented a
forall a. [Maybe a] -> Maybe a -> Fragmented a
Fragmented (Maybe a
forall a. Maybe a
Nothing Maybe a -> [Maybe a] -> [Maybe a]
forall a. a -> [a] -> [a]
: [Maybe a]
xs) Maybe a
x