Using the new simpleFigure function.

[argent0]

Hello, this is the preliminary code for the markdown reader:

Diff

diff --git a/src/Text/Pandoc/Readers/Markdown.hs b/src/Text/Pandoc/Readers/Markdown.hs
index 1e9867d07..904595c39 100644
--- a/src/Text/Pandoc/Readers/Markdown.hs
+++ b/src/Text/Pandoc/Readers/Markdown.hs
@@ -1013,19 +1013,18 @@ normalDefinitionList = do
 para :: PandocMonad m => MarkdownParser m (F Blocks)
 para = try $ do
   exts <- getOption readerExtensions
-  let implicitFigures x
-       | extensionEnabled Ext_implicit_figures exts = do
-         x' <- x
-         case B.toList x' of
-               [Image attr alt (src,tit)]
-                 | not (null alt) ->
-                    -- the fig: at beginning of title indicates a figure
-                    return $ B.singleton
-                           $ Image attr alt (src, "fig:" <> tit)
-               _ -> return x'
-       | otherwise = x
-  result <- implicitFigures . trimInlinesF <$> inlines1
-  option (B.plain <$> result)
+
+  result <- trimInlinesF <$> inlines1
+  let figureOr constr inlns =
+        case B.toList inlns of
+          [Image attr figCaption (src, tit)]
+            | extensionEnabled Ext_implicit_figures exts
+            , not (null figCaption) -> do
+                B.simpleFigureWith attr figCaption src tit
+
+          _ -> constr inlns
+
+  option (figureOr B.plain <$> result)
     $ try $ do
             newline
             (mempty <$ blanklines)
@@ -1047,7 +1046,7 @@ para = try $ do
                      if divLevel > 0
                         then lookAhead divFenceEnd
                         else mzero
-            return $ B.para <$> result
+            return $ figureOr B.para <$> result
 
 plain :: PandocMonad m => MarkdownParser m (F Blocks)
 plain = fmap B.plain . trimInlinesF <$> inlines1

Resulting Function

para :: PandocMonad m => MarkdownParser m (F Blocks)
para = try $ do
  exts <- getOption readerExtensions

  -- tarleb's
  result <- trimInlinesF <$> inlines1
  let figureOr constr inlns =
        case B.toList inlns of
          [Image attr alt (src, tit)]
            | extensionEnabled Ext_implicit_figures exts
            , not (null alt) -> do
                B.simpleFigureWith attr alt src tit

          _ -> constr inlns

  option (figureOr B.plain <$> result)
    $ try $ do
            newline
            (mempty <$ blanklines)
              <|> (guardDisabled Ext_blank_before_blockquote >> () <$ lookAhead blockQuote)
              <|> (guardEnabled Ext_backtick_code_blocks >> () <$ lookAhead codeBlockFenced)
              <|> (guardDisabled Ext_blank_before_header >> () <$ lookAhead header)
              <|> (guardEnabled Ext_lists_without_preceding_blankline >>
                       -- Avoid creating a paragraph in a nested list.
                       notFollowedBy' inList >>
                       () <$ lookAhead listStart)
              <|> do guardEnabled Ext_native_divs
                     inHtmlBlock <- stateInHtmlBlock <$> getState
                     case inHtmlBlock of
                          Just "div" -> () <$
                                       lookAhead (htmlTag (~== TagClose ("div" :: Text)))
                          _          -> mzero
              <|> do guardEnabled Ext_fenced_divs
                     divLevel <- stateFencedDivLevel <$> getState
                     if divLevel > 0
                        then lookAhead divFenceEnd
                        else mzero
            return $ figureOr B.para <$> result

This replaces the function here

[cderv]

This replaces the function here

@argent0 can you share the diff directly here too that the changes can be seen easily ?
You can do that by copy pasting a git diff result in a Markdown code block in Github like this

```diff
<copy paste your git diff result>
```

Ex: https://stackoverflow.com/a/40883538/3436535

Thanks you !

[argent0]

I've updated the OP

[tarleb]

Wow, that's cool! I learned something new :)

[cderv]

Yes it really is cool to quickly share some diff without having to commit, compare branches or do a PR.
You can even write by hand, but often that it is no easy 😅 - just add + or - in front of the line.

Hello, 
- I am the old line
+ I am the new line
See you!

[tarleb]

How about this:

diff --git a/src/Text/Pandoc/Readers/Markdown.hs b/src/Text/Pandoc/Readers/Markdown.hs
index 1e9867d07..6db492e70 100644
--- a/src/Text/Pandoc/Readers/Markdown.hs
+++ b/src/Text/Pandoc/Readers/Markdown.hs
@@ -1013,18 +1013,16 @@ normalDefinitionList = do
 para :: PandocMonad m => MarkdownParser m (F Blocks)
 para = try $ do
   exts <- getOption readerExtensions
-  let implicitFigures x
-       | extensionEnabled Ext_implicit_figures exts = do
-         x' <- x
-         case B.toList x' of
-               [Image attr alt (src,tit)]
-                 | not (null alt) ->
-                    -- the fig: at beginning of title indicates a figure
-                    return $ B.singleton
-                           $ Image attr alt (src, "fig:" <> tit)
-               _ -> return x'
-       | otherwise = x
-  result <- implicitFigures . trimInlinesF <$> inlines1
+  result <- trimInlinesF <$> inlines1
+  let paraOrFigure inlns =
+        case B.toList inlns of
+          [Image attr alt (src, tit)]
+            | extensionEnabled Ext_implicit_figures exts
+            , not (null alt) -> do
+                -- the fig: at beginning of title indicates a figure
+                B.para $ B.singleton
+                  $ Image attr alt (src, "fig:" <> tit)
+          _ -> B.para inlns
   option (B.plain <$> result)
     $ try $ do
             newline
@@ -1047,7 +1045,7 @@ para = try $ do
                      if divLevel > 0
                         then lookAhead divFenceEnd
                         else mzero
-            return $ B.para <$> result
+            return $ paraOrFigure <$> result
 
 plain :: PandocMonad m => MarkdownParser m (F Blocks)
 plain = fmap B.plain . trimInlinesF <$> inlines1

A bit hacky though.

[tarleb]

Ok, this would break jgm#5368. I don't have a good idea right away; might be worth bringing up on pandoc-discuss.

[tarleb]

This here seems to work and doesn't break any tests.

diff --git a/src/Text/Pandoc/Readers/Markdown.hs b/src/Text/Pandoc/Readers/Markdown.hs
index 1e9867d07..dc0ae2273 100644
--- a/src/Text/Pandoc/Readers/Markdown.hs
+++ b/src/Text/Pandoc/Readers/Markdown.hs
@@ -1013,19 +1013,17 @@ normalDefinitionList = do
 para :: PandocMonad m => MarkdownParser m (F Blocks)
 para = try $ do
   exts <- getOption readerExtensions
-  let implicitFigures x
-       | extensionEnabled Ext_implicit_figures exts = do
-         x' <- x
-         case B.toList x' of
-               [Image attr alt (src,tit)]
-                 | not (null alt) ->
-                    -- the fig: at beginning of title indicates a figure
-                    return $ B.singleton
-                           $ Image attr alt (src, "fig:" <> tit)
-               _ -> return x'
-       | otherwise = x
-  result <- implicitFigures . trimInlinesF <$> inlines1
-  option (B.plain <$> result)
+  result <- trimInlinesF <$> inlines1
+  let figureOr constr inlns =
+        case B.toList inlns of
+          [Image attr alt (src, tit)]
+            | extensionEnabled Ext_implicit_figures exts
+            , not (null alt) -> do
+                -- the fig: at beginning of title indicates a figure
+                B.para $ B.singleton
+                  $ Image attr alt (src, "fig:" <> tit)
+          _ -> constr inlns
+  option (figureOr B.plain <$> result)
     $ try $ do
             newline
             (mempty <$ blanklines)
@@ -1047,7 +1045,7 @@ para = try $ do
                      if divLevel > 0
                         then lookAhead divFenceEnd
                         else mzero
-            return $ B.para <$> result
+            return $ figureOr B.para <$> result
 
 plain :: PandocMonad m => MarkdownParser m (F Blocks)
 plain = fmap B.plain . trimInlinesF <$> inlines1

Not sure if that can cause problems later, but it's probably fine.

[argent0]

Thanks, I'll update the OP following your suggestion.

[tarleb]

I'm wondering whether we could simplify our task by adding another helper function; maybe something along these lines:

-- | Converts a singleton containing an image into a figure; 
-- returns @Nothing@ if that's not possible.
imageToFigure :: Inlines -> Maybe Blocks
imageToFigure = undefined

It seems that this operation is a common occurrence in the readers.

[tarleb]

Also maybe implicitFigureToFigure :: Blocks -> Blocks?

[argent0]

I was also thinking in something along the lines of:

simpleFigureBlockWith :: ... -> Block
simpleFigureBlockWith attr figureCaption url title =
  Para [Image attr figureCaption (url, "fig:" <> title)]

for the LaTex reader.

But I agree that maybe it's necessary to expand the repertoire of functions beyond simpleFigure.

[tarleb]

That would be a good alternative. Better yet, we can make use of a pattern SimpleFigure pattern synonym to do this.

[argent0]

But can you "compute" in a pattern synonym?

"fig:" <> ...

I also attempted:

pattern SimpleFigure attr figureCaption url title =
  Para [Image attr figureCaption (url, 'f' : 'i' : 'g' : ':' : title)]

But

• Couldn't match expected type ‘Text’ with actual type ‘[Char]’
    • In the pattern: 'f' : 'i' : 'g' : ':' : title
      In the pattern: (url, 'f' : 'i' : 'g' : ':' : title)
      In the pattern:
        Image attr figureCaption (url, 'f' : 'i' : 'g' : ':' : title)
     |
1097 |   Para [Image attr figureCaption (url, 'f' : 'i' : 'g' : ':' : title)]
     |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

[tarleb]

But can you "compute" in a pattern synonym?

It's not simple, but possible when combining pattern synonyms with view patterns. The following example illustrates the method. Running it with `stack test.hs` yields `nny`. ```haskell #!/usr/bin/env stack -- stack --resolver lts-17.15 script {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE ViewPatterns #-} import Data.Text (Text) import qualified Data.Text as T import qualified Data.Text.IO as T newtype Foo = Foo Text pattern Fubar :: Text -> Foo pattern Fubar bar <- Foo (T.stripPrefix "fu" -> Just bar) main :: IO () main = do case Foo "funny" of Fubar title -> T.putStrLn title _ -> T.putStrLn "no match" ```