Add support for triple-quoted sigils

src/pearl.gleam

···
 import gleam/int
 import gleam/list
+import gleam/option.{type Option, None, Some}
 import gleam/string
 import pearl/token.{type Token}
 import splitter.{type Splitter}
···
     | "9" as char <> source ->
       lex_number(advance(lexer, source), char, Initial, AfterNumber)
 
-    "\"\"\"" <> source -> lex_triple_quoted_string(advance(lexer, source))
+    "\"\"\"" <> source -> lex_triple_quoted_string(advance(lexer, source), None)
 
     "\"" <> source -> lex_string(advance(lexer, source), "")
     "'" <> source -> lex_quoted_atom(advance(lexer, source), "")
···
     _ -> #(lexer, "", False)
   }
 
-  let #(lexer, delimiter, closing_char) = case lexer.source {
-    "(" <> source -> #(advance(lexer, source), token.SigilParen, ")")
-    "[" <> source -> #(advance(lexer, source), token.SigilSquare, "]")
-    "{" <> source -> #(advance(lexer, source), token.SigilBrace, "}")
-    "<" <> source -> #(advance(lexer, source), token.SigilAngle, ">")
+  case lexer.source {
+    "\"\"\"" <> source ->
+      lex_triple_quoted_string(advance(lexer, source), Some(sigil))
+    _ -> {
+      let #(lexer, delimiter, closing_char) = case lexer.source {
+        "(" <> source -> #(advance(lexer, source), token.SigilParen, ")")
+        "[" <> source -> #(advance(lexer, source), token.SigilSquare, "]")
+        "{" <> source -> #(advance(lexer, source), token.SigilBrace, "}")
+        "<" <> source -> #(advance(lexer, source), token.SigilAngle, ">")
 
-    "/" <> source -> #(advance(lexer, source), token.SigilSlash, "/")
-    "|" <> source -> #(advance(lexer, source), token.SigilPipe, "|")
-    "'" <> source -> #(advance(lexer, source), token.SigilSingleQuote, "'")
-    "\"" <> source -> #(advance(lexer, source), token.SigilDoubleQuote, "\"")
-    "`" <> source -> #(advance(lexer, source), token.SigilBacktick, "`")
-    "#" <> source -> #(advance(lexer, source), token.SigilHash, "#")
+        "/" <> source -> #(advance(lexer, source), token.SigilSlash, "/")
+        "|" <> source -> #(advance(lexer, source), token.SigilPipe, "|")
+        "'" <> source -> #(advance(lexer, source), token.SigilSingleQuote, "'")
+        "\"" <> source -> #(
+          advance(lexer, source),
+          token.SigilDoubleQuote,
+          "\"",
+        )
+        "`" <> source -> #(advance(lexer, source), token.SigilBacktick, "`")
+        "#" <> source -> #(advance(lexer, source), token.SigilHash, "#")
 
-    _ -> #(error(lexer, ExpectedSigilDelimiter), token.SigilNone, "")
-  }
+        _ -> #(error(lexer, ExpectedSigilDelimiter), token.SigilNone, "")
+      }
+
+      case delimiter {
+        token.SigilNone -> #(
+          lexer,
+          token.UnterminatedSigil(sigil:, delimiter:, contents: ""),
+        )
+        _ -> {
+          let splitter = case verbatim {
+            False -> lexer.splitters.sigil
+            True -> lexer.splitters.sigil_verbatim
+          }
 
-  case delimiter {
-    token.SigilNone -> #(
-      lexer,
-      token.UnterminatedSigil(sigil:, delimiter:, contents: ""),
-    )
-    _ -> {
-      let splitter = case verbatim {
-        False -> lexer.splitters.sigil
-        True -> lexer.splitters.sigil_verbatim
+          do_lex_sigil(lexer, sigil, delimiter, closing_char, splitter, "")
+        }
       }
-
-      do_lex_sigil(lexer, sigil, delimiter, closing_char, splitter, "")
     }
   }
 }
···
   }
 }
 
-fn lex_triple_quoted_string(lexer: Lexer) -> #(Lexer, Token) {
+fn lex_triple_quoted_string(
+  lexer: Lexer,
+  sigil: Option(String),
+) -> #(Lexer, Token) {
   let #(lexer, beginning_whitespace) = case
     splitter.split(lexer.splitters.until_end_of_line, lexer.source)
   {
···
     }
     Ok(lines) -> #(
       lexer,
-      token.TripleQuotedString(beginning_whitespace:, lines:, end_indentation:),
+      token.TripleQuotedString(
+        sigil:,
+        beginning_whitespace:,
+        lines:,
+        end_indentation:,
+      ),
     )
   }
 }

src/pearl/token.gleam

···
 import gleam/list
+import gleam/option
 import gleam/string
 
 pub type Token {
···
   Atom(name: String, quoted: Bool)
   String(String)
   TripleQuotedString(
+    sigil: option.Option(String),
     beginning_whitespace: String,
     lines: List(String),
     end_indentation: String,
···
     Atom(name:, quoted: True) -> "'" <> name <> "'"
     Atom(name:, quoted: False) -> name
     String(contents) -> "\"" <> contents <> "\""
-    TripleQuotedString(beginning_whitespace:, lines:, end_indentation:) ->
-      "\"\"\""
+    TripleQuotedString(sigil:, beginning_whitespace:, lines:, end_indentation:) ->
+      case sigil {
+        option.None -> ""
+        option.Some(sigil) -> "~" <> sigil
+      }
+      <> "\"\"\""
       <> beginning_whitespace
       <> string.join(
         list.map(lines, fn(line) { end_indentation <> line }),

test/pearl_test.gleam

···
 import gleam/list
+import gleam/option.{None, Some}
 import gleeunit
 import pearl
 import pearl/token
···
 
   assert_tokens(src, [
     token.TripleQuotedString(
+      sigil: None,
       beginning_whitespace: "  \n",
       lines: [
         "Hello, this is triple-quoted!",
···
         "Quotes are allowed: \"\", even three: \"\"\"",
       ],
       end_indentation: "\t ",
+    ),
+  ])
+}
+
+pub fn triple_quoted_string_sigil_test() {
+  let src =
+    "
+~b\"\"\"
+  Hello
+  This is a triple-quoted sigil
+  \"\"\"
+"
+
+  assert_tokens(src, [
+    token.TripleQuotedString(
+      sigil: Some("b"),
+      beginning_whitespace: "\n",
+      lines: ["Hello", "This is a triple-quoted sigil"],
+      end_indentation: "  ",
     ),
   ])
 }

test/tokens.txt

···
   Three quotes allowed here: """ and here: """
   """
 
+~B""" 
+  Triple quote sigil!
+  bye
+  """
+
 after
 begin
 case