markdown: Support multiline HTML blocks

This is needed by “Demystifying MonadBaseControl”.

Author: lexi-lambda

blog/build.rkt

@@ -70,7 +70,7 @@
                        "2018-09-13-custom-core-forms-in-racket-part-ii-generalizing-to-arbitrary-expressions-and-internal-definitions.md"
                        "2018-10-06-macroexpand-anywhere-with-local-apply-transformer.md"
                        "2019-04-21-defeating-racket-s-separate-compilation-guarantee.md"
-                       #;"2019-09-07-demystifying-monadbasecontrol.md" ; html tables
+                       "2019-09-07-demystifying-monadbasecontrol.md"
                        "2019-10-19-empathy-and-subjective-experience-in-programming-languages.md"
                        "2019-11-05-parse-don-t-validate.md"
                        "2020-01-19-no-dynamic-type-systems-are-not-inherently-more-open.md"

blog/markdown/parse.rkt

@@ -8,6 +8,7 @@
          racket/function
          racket/list
          racket/match
+         racket/string
          threading
          xml
          "parse/content.rkt"
@@ -313,7 +314,7 @@ As it parses the indentation for each block, it transfers it from the
         ; html blocks
         (do (lookahead/p (or/p (try/p (string/p "<div"))
                                (try/p (string/p "<h2"))))
-            [html-str <- rest-of-line/p]
+            [html-str <- (map/p string-append* (many-till/p rest-of-line/p newline/p))]
             (scan-line-start (reverse (cons (add-blocks inner-block (list (html-block (string->xexpr html-str)))) in-blocks))))
 
         ; free-form content (new paragraph)

blog/markdown/parse/content.rkt

@@ -55,18 +55,25 @@
 
 ;; -----------------------------------------------------------------------------
 
-(define special-chars "*`[]<!\\\r\n")
+(define special-chars "_*`[]<!\\ \r\n")
 
 (define content/p
   (label/p "content"
-    (or/p (map/p list->string ((pure cons) (char-not-in/p (string-append "_" special-chars))
-                                           ; allow _ to appear inside words
-                                           (many/p (char-not-in/p special-chars))))
+    (or/p (map/p string-append*
+                 (many+/p (or/p
+                           ; allow _ to appear inside words
+                           (try/p ((pure string) (char-not-in/p special-chars)
+                                                 (char/p #\_)
+                                                 (char-not-in/p special-chars)))
+                           (map/p string (char-not-in/p special-chars)))))
+          ; spaces
+          (map/p list->string (many+/p (char/p #\space)))
           ; escaped char
           (do (char/p #\\) (map/p string any-char/p))
           ; bold / italic
           (map/p (λ~> simplify-content bold) (around/p (try/p (string/p "**")) (lazy/p content/p)))
           (map/p (λ~> simplify-content italic) (around/p (char/p #\*) (lazy/p content/p)))
+          (map/p (λ~> simplify-content italic) (around/p (char/p #\_) (lazy/p content/p)))
           ; code
           (do [backticks <- (many+/p (char/p #\`))]
               [chars <- (many-till/p any-char/p (try/p (string/p (list->string backticks))))]

blog/markdown/to-scribble.rkt

@@ -128,10 +128,10 @@
 
 (define (xexpr->block xexpr)
   (match xexpr
-    [(list (? symbol? tag) (list (list (? symbol? attr-name) (? string? attr-val)) ...) xexpr ...)
+    [(list (? symbol? tag) (list (list (? symbol? attr-name) (? string? attr-val)) ...) xexprs ...)
      (paragraph (style #f (list (alt-tag (symbol->string tag))
                                 (attributes (map cons attr-name attr-val))))
-                (map xexpr->content xexpr))]))
+                (map xexpr->content xexprs))]))
 
 (define (xexpr->content xexpr)
   (match xexpr

blog/posts/2019-09-07-demystifying-monadbasecontrol.md

@@ -182,30 +182,30 @@ instance MonadBaseControl b m => MonadBaseControl b (StateT s m) where
 
   1. Start by examining the definitions of `InputState` and `OutputState`. Are they what you expected? You’d be forgiven for expecting the following:
 
-    ```haskell
-    type InputState (StateT s m) = s
-    type OutputState (StateT s m) = s
-    ```
+     ```haskell
+     type InputState (StateT s m) = s
+     type OutputState (StateT s m) = s
+     ```
 
-    After all, that’s what we wrote in the table, isn’t it?
+     After all, that’s what we wrote in the table, isn’t it?
 
-    However, if you give it a try, you’ll find it doesn’t work. `InputState` and `OutputState` must capture the state of the *entire* monad, not just a single transformer layer, so we have to combine the `StateT s` state with the state of the underlying monad. In the simplest case we get
+     However, if you give it a try, you’ll find it doesn’t work. `InputState` and `OutputState` must capture the state of the *entire* monad, not just a single transformer layer, so we have to combine the `StateT s` state with the state of the underlying monad. In the simplest case we get
 
-    ```haskell
-    InputState (StateT s IO) = (s, ())
-    ```
+     ```haskell
+     InputState (StateT s IO) = (s, ())
+     ```
 
-    which is boring, but in a more complex case, we need to get something like this:
+     which is boring, but in a more complex case, we need to get something like this:
 
-    ```haskell
-    InputState (StateT s (ReaderT IO)) = (s, (r, ()))
-    ```
+     ```haskell
+     InputState (StateT s (ReaderT IO)) = (s, (r, ()))
+     ```
 
-    Therefore, `InputState (StateT s m)` combines `s` with `InputState m` in a tuple, and `OutputState` does the same.
+     Therefore, `InputState (StateT s m)` combines `s` with `InputState m` in a tuple, and `OutputState` does the same.
 
   2. Moving on, take a look at `captureInputState` and `closeOverInputState`. Just as `InputState` and `OutputState` capture the state of the entire monad, these functions need to be inductive in the same way.
 
-    `captureInputState` acquires the current state using `get`, and it combines it with the remaining monadic state using `lift captureInputState`. `closeOverInputState` uses the captured state to peel off the outermost `StateT` layer, then calls `closeOverInputState` recursively to peel off the rest of them.
+     `captureInputState` acquires the current state using `get`, and it combines it with the remaining monadic state using `lift captureInputState`. `closeOverInputState` uses the captured state to peel off the outermost `StateT` layer, then calls `closeOverInputState` recursively to peel off the rest of them.
 
   3. Finally, `restoreOutputState` restores the state of the underlying monad stack, then restores the `StateT` state, ensuring everything ends up back the way it’s supposed to be.