Fix: adapt case studies to also work on the website (#1022)

- Sometimes there were function definitions spanning across multiple
code blocks, which is no longer supported by the new "unified" literate
Effekt behaviour (#1009). I merged these blocks and added the
explanation beneath.
- I solved an ambiguous usage of `Success` and `Failure` by renaming it
to `ParseSuccess` and `ParseFailure` as `module21::Success` for example
would be rather awkward (and would not work locally).
- Also fixed a bug which discarded empty lines in code blocks in
literate Effekt files.

Author: dvdvgt

effekt/shared/src/main/scala/effekt/util/Source.scala

@@ -68,7 +68,7 @@ case class MarkdownSource(source: Source) extends Source {
                   lines += "}"
                 // closing fence of ```effekt or ```
                 case Code =>
-                  lines ++= code
+                  if (!code.isEmpty) lines ++= code
                   lines += ""
                 // closing fence of ```effekt:ignore
                 case Ignore =>
@@ -83,7 +83,7 @@ case class MarkdownSource(source: Source) extends Source {
           }
         }
       // collect code if in code fence
-      case line if fenceType.isDefined && line != "" =>
+      case line if fenceType.isDefined =>
         code += line
       // add empty lines to preserve positional information outside of code fences
       case line =>

examples/casestudies/anf.effekt.md

@@ -77,17 +77,15 @@ def traverse(e: Tree): Stmt / { Bind, Fresh } = e match {
     // should be inserted.
     CLet(x, bindHere { traverse(b) }, bindHere { traverse(body) })
 }
-```
-The handler `bindHere` handles `Bind` by generating a fresh name and
-inserting a let binding:
-```
+
 def bindHere { prog: => Stmt / Bind } : Stmt / Fresh =
   try { prog() }
   with Bind { (e) =>
     val id = do Fresh()
     CLet(id, e, resume(CVar(id)))
   }
 ```
+The handler `bindHere` handles `Bind` by generating a fresh name and inserting a let binding.
 Note, that the let binding will _enclose_ the overall result of `prog`. It is inserted on the outside.
 
 The overall ANF transformation is simply a matter of composing the two handlers and calling `traverse`:
@@ -158,8 +156,8 @@ our input:
 ```
 def pipeline(input: String): String =
   parse(input) { parseExpr() } match {
-    case parser::Success(tree) => pretty(translate(tree))
-    case parser::Failure(msg) => msg
+    case ParseSuccess(tree) => pretty(translate(tree))
+    case ParseFailure(msg) => msg
   }
 ```
 

examples/casestudies/frontend.check

@@ -4,19 +4,19 @@ Tuple3(Token(Ident(), foo, Position(1, 1, 0)), Token(Punct(), (, Position(1, 4,
 ()
 Tuple3(Token(Ident(), foo, Position(1, 1, 0)), Token(Punct(), (, Position(1, 5, 4)), Token(Punct(), ), Position(2, 2, 11)))
 ()
-Success(1)
-Success(2)
-Success(3)
-Success(5)
-Success(6)
-Success(6)
-Failure(Expected ( but got })
-Success(Lit(42))
-Success(Let(x, Lit(4), Lit(42)))
-Success(Let(x, Let(y, Lit(2), Lit(1)), Lit(42)))
-Success(Let(x, Let(y, Lit(2), Lit(1)), Lit(42)))
-Success(Let(x, Let(y, App(f, Lit(42)), Lit(1)), Lit(42)))
-Success(Let(x, Let(y, App(f, Let(z, Lit(1), Var(z))), Lit(1)), Lit(42)))
+ParseSuccess(1)
+ParseSuccess(2)
+ParseSuccess(3)
+ParseSuccess(5)
+ParseSuccess(6)
+ParseSuccess(6)
+ParseFailure(Expected ( but got })
+ParseSuccess(Lit(42))
+ParseSuccess(Let(x, Lit(4), Lit(42)))
+ParseSuccess(Let(x, Let(y, Lit(2), Lit(1)), Lit(42)))
+ParseSuccess(Let(x, Let(y, Lit(2), Lit(1)), Lit(42)))
+ParseSuccess(Let(x, Let(y, App(f, Lit(42)), Lit(1)), Lit(42)))
+ParseSuccess(Let(x, Let(y, App(f, Let(z, Lit(1), Var(z))), Lit(1)), Lit(42)))
 ()
 -----
 [1,