:sparkles: Fail the review if there's tests with duplicate titles

* :construction: Add `birdie/internal/titles` module

* :sparkles: Refine titles implementation and add error messages

* :memo: Update README

* :memo: CHANGELOG!

CHANGELOG.md

···
 # Changelog
 
+## Unreleased
+
+- ✨ Fail the review if there's tests with duplicate titles
+
 ## v1.0.4 - 2024-02-01
 
 - ➖ Drop the `glam` dependency

README.md

···
 Also all snapshots _must_ have unique names so that birdie won't mix those up,
 so be careful when naming snapshots to not repeat the same title twice!
 
+> During the review process, Birdie will try to be helpful and show you an
+> error message if it can spot two tests that happen to share the same exact
+> title. It will only work for snapshots that have a literal string as a title
+> but it can be really helpful to spot some of those confusing bugs!
+
 ### How big should the snapshot's content be?
 
 My recommendation is strive to have small and cohesive snapshots. Each

birdie_snapshots/can_find_literal_titles_when_calling_`birdie_snap`.accepted

···
+---
+version: 1.0.4
+title: can find literal titles when calling `birdie.snap`
+file: ./test/titles_test.gleam
+test_name: can_find_literal_titles_when_calling_birdie_snap_test
+---
+--- LITERALS ---
+with function capture and labels         [in_pipeline_with_piped_title - my/module]
+with function capture and no labels      [in_pipeline_with_piped_title - my/module]
+with function capture and some labels    [in_pipeline_with_piped_title - my/module]
+with just content label                  [direct_call - my/module]
+with just title label                    [direct_call - my/module]
+with label                               [in_pipeline_with_piped_content - my/module]
+with labels                              [direct_call - my/module]
+with no labels                           [direct_call - my/module]
+with swapped labels                      [direct_call - my/module]
+without function capture and labelled content [in_pipeline_with_piped_title - my/module]
+without label                            [in_pipeline_with_piped_content - my/module]
+
+--- PREFIXES ---

birdie_snapshots/can_find_literal_titles_when_calling_`snap`.accepted

···
+---
+version: 1.0.4
+title: can find literal titles when calling `snap`
+file: ./test/titles_test.gleam
+test_name: can_find_literal_titles_when_calling_snap_test
+---
+--- LITERALS ---
+with function capture and labels         [in_pipeline_with_piped_title - my/module]
+with function capture and no labels      [in_pipeline_with_piped_title - my/module]
+with function capture and some labels    [in_pipeline_with_piped_title - my/module]
+with just content label                  [direct_call - my/module]
+with just title label                    [direct_call - my/module]
+with label                               [in_pipeline_with_piped_content - my/module]
+with labels                              [direct_call - my/module]
+with no labels                           [direct_call - my/module]
+with swapped labels                      [direct_call - my/module]
+without function capture and labelled content [in_pipeline_with_piped_title - my/module]
+without label                            [in_pipeline_with_piped_content - my/module]
+
+--- PREFIXES ---

birdie_snapshots/can_find_literal_titles_when_calling_aliased_`b_snap`.accepted

···
+---
+version: 1.0.4
+title: can find literal titles when calling aliased `b.snap`
+file: ./test/titles_test.gleam
+test_name: can_find_literal_titles_when_calling_aliased_birdie_snap_test
+---
+--- LITERALS ---
+with function capture and labels         [in_pipeline_with_piped_title - my/module]
+with function capture and no labels      [in_pipeline_with_piped_title - my/module]
+with function capture and some labels    [in_pipeline_with_piped_title - my/module]
+with just content label                  [direct_call - my/module]
+with just title label                    [direct_call - my/module]
+with label                               [in_pipeline_with_piped_content - my/module]
+with labels                              [direct_call - my/module]
+with no labels                           [direct_call - my/module]
+with swapped labels                      [direct_call - my/module]
+without function capture and labelled content [in_pipeline_with_piped_title - my/module]
+without label                            [in_pipeline_with_piped_content - my/module]
+
+--- PREFIXES ---

birdie_snapshots/can_find_literal_titles_when_calling_aliased_`s`.accepted

···
+---
+version: 1.0.4
+title: can find literal titles when calling aliased `s`
+file: ./test/titles_test.gleam
+test_name: can_find_literal_titles_when_calling_aliased_snap_test
+---
+--- LITERALS ---
+with function capture and labels         [in_pipeline_with_piped_title - my/module]
+with function capture and no labels      [in_pipeline_with_piped_title - my/module]
+with function capture and some labels    [in_pipeline_with_piped_title - my/module]
+with just content label                  [direct_call - my/module]
+with just title label                    [direct_call - my/module]
+with label                               [in_pipeline_with_piped_content - my/module]
+with labels                              [direct_call - my/module]
+with no labels                           [direct_call - my/module]
+with swapped labels                      [direct_call - my/module]
+without function capture and labelled content [in_pipeline_with_piped_title - my/module]
+without label                            [in_pipeline_with_piped_content - my/module]
+
+--- PREFIXES ---

birdie_snapshots/can_read_the_snap_titles_from_the_project_itself.accepted

···
+---
+version: 1.0.4
+title: can read the snap titles from the project itself
+file: ./test/titles_test.gleam
+test_name: can_read_the_snap_titles_from_the_project_itself_test
+---
+--- LITERALS ---
+can find literal titles when calling `birdie.snap` [can_find_literal_titles_when_calling_birdie_snap_test - ./test/titles_test.gleam]
+can find literal titles when calling `snap` [can_find_literal_titles_when_calling_snap_test - ./test/titles_test.gleam]
+can find literal titles when calling aliased `b.snap` [can_find_literal_titles_when_calling_aliased_birdie_snap_test - ./test/titles_test.gleam]
+can find literal titles when calling aliased `s` [can_find_literal_titles_when_calling_aliased_snap_test - ./test/titles_test.gleam]
+can read the snap titles from the project itself [can_read_the_snap_titles_from_the_project_itself_test - ./test/titles_test.gleam]
+diffing a case expression                [complex_function_test - ./test/birdie_test.gleam]
+my favourite number wrapped in a result  [a_result_test - ./test/birdie_test.gleam]
+my first snapshot                        [hello_birdie_test - ./test/birdie_test.gleam]
+snapping a list of numbers               [list_test - ./test/birdie_test.gleam]
+
+--- PREFIXES ---

birdie_snapshots/diffing_a_case_expression.accepted

···
 ---
-version: 1.0.3
+version: 1.0.4
 title: diffing a case expression
+file: ./test/birdie_test.gleam
+test_name: complex_function_test
 ---
 case foo(bar, baz) {
   True ->

birdie_snapshots/my_favourite_number_wrapped_in_a_result.accepted

···
 ---
-version: 1.0.3
+version: 1.0.4
 title: my favourite number wrapped in a result
+file: ./test/birdie_test.gleam
+test_name: a_result_test
 ---
 Ok(11)

birdie_snapshots/my_first_snapshot.accepted

···
 ---
-version: 1.0.3
+version: 1.0.4
 title: my first snapshot
+file: ./test/birdie_test.gleam
+test_name: hello_birdie_test
 ---
 🐦‍⬛ smile for the birdie!

birdie_snapshots/my_first_snapshot.new

···
+---
+version: 1.0.4
+title: my first snapshot
+---
+🐦‍⬛ smile for birdie!

birdie_snapshots/snapping_a_list_of_numbers.accepted

···
 ---
-version: 1.0.3
+version: 1.0.4
 title: snapping a list of numbers
+file: ./test/birdie_test.gleam
+test_name: list_test
 ---
 [ 1, 2, 3, 4 ]

gleam.toml

···
 gleam_erlang = "~> 0.24"
 rank = "~> 1.0"
 gleeunit = "~> 1.0"
+glance = "~> 0.8"
+trie_again = "~> 1.1"

manifest.toml

···
 
 packages = [
   { name = "argv", version = "1.0.1", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "A6E9009E50BBE863EB37D963E4315398D41A3D87D0075480FC244125808F964A" },
-  { name = "filepath", version = "0.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "534E8161A0DE192A9A105EFEC34369E9FD5834BB58ED449B5ACAEE8704358588" },
+  { name = "filepath", version = "0.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "FC1B1B29438A5BA6C990F8047A011430BEC0C5BA638BFAA62718C4EAEFE00435" },
   { name = "gap", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_community_ansi", "gleam_stdlib"], otp_app = "gap", source = "hex", outer_checksum = "2EE1B0A17E85CF73A0C1D29DA315A2699117A8F549C8E8D89FA8261BE41EDEB1" },
+  { name = "glance", version = "0.8.2", build_tools = ["gleam"], requirements = ["gleam_stdlib", "glexer"], otp_app = "glance", source = "hex", outer_checksum = "ACF09457E8B564AD7A0D823DAFDD326F58263C01ACB0D432A9BEFDEDD1DA8E73" },
   { name = "gleam_community_ansi", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_community_colour", "gleam_stdlib"], otp_app = "gleam_community_ansi", source = "hex", outer_checksum = "FE79E08BF97009729259B6357EC058315B6FBB916FAD1C2FF9355115FEB0D3A4" },
   { name = "gleam_community_colour", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_community_colour", source = "hex", outer_checksum = "A49A5E3AE8B637A5ACBA80ECB9B1AFE89FD3D5351FF6410A42B84F666D40D7D5" },
   { name = "gleam_erlang", version = "0.24.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "26BDB52E61889F56A291CB34167315780EE4AA20961917314446542C90D1C1A0" },
-  { name = "gleam_stdlib", version = "0.34.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "1FB8454D2991E9B4C0C804544D8A9AD0F6184725E20D63C3155F0AEB4230B016" },
+  { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
   { name = "gleeunit", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D364C87AFEB26BDB4FB8A5ABDE67D635DC9FA52D6AB68416044C35B096C6882D" },
+  { name = "glexer", version = "0.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glexer", source = "hex", outer_checksum = "4484942A465482A0A100936E1E5F12314DB4B5AC0D87575A7B9E9062090B96BE" },
   { name = "justin", version = "1.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "justin", source = "hex", outer_checksum = "7FA0C6DB78640C6DC5FBFD59BF3456009F3F8B485BF6825E97E1EB44E9A1E2CD" },
   { name = "rank", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "rank", source = "hex", outer_checksum = "5660E361F0E49CBB714CC57CC4C89C63415D8986F05B2DA0C719D5642FAD91C9" },
-  { name = "simplifile", version = "1.3.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "059AEB3632D1EBF4C943E8C231DBD8861A8BBF2984B78C1FE49159F28338A1FF" },
+  { name = "simplifile", version = "1.5.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "EB9AA8E65E5C1E3E0FDCFC81BC363FD433CB122D7D062750FFDF24DE4AC40116" },
+  { name = "trie_again", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "trie_again", source = "hex", outer_checksum = "5B19176F52B1BD98831B57FDC97BD1F88C8A403D6D8C63471407E78598E27184" },
 ]
 
 [requirements]
 argv = { version = "~> 1.0" }
 filepath = { version = "~> 0.1" }
 gap = { version = "~> 1.1" }
+glance = { version = "~> 0.8" }
 gleam_community_ansi = { version = "~> 1.4" }
 gleam_erlang = { version = "~> 0.24" }
 gleam_stdlib = { version = "~> 0.34 or ~> 1.0" }
···
 justin = { version = "~> 1.0" }
 rank = { version = "~> 1.0" }
 simplifile = { version = "~> 1.2" }
+trie_again = { version = "~> 1.1" }

src/birdie.gleam

···
 import gleam_community/ansi
 import argv
 import birdie/internal/diff.{type DiffLine, DiffLine}
+import birdie/internal/project
+import birdie/internal/titles
 import filepath
 import gleeunit/should
 import justin
···
   CorruptedSnapshot(source: String)
 
   CannotFindProjectRoot(reason: simplifile.FileError)
+
+  CannotGetTitles(reason: titles.Error)
 }
 
 // --- THE SNAPSHOT TYPE -------------------------------------------------------
···
 type Accepted
 
 type Snapshot(status) {
-  Snapshot(title: String, content: String)
+  Snapshot(title: String, content: String, info: Option(titles.TestInfo))
 }
 
 // --- SNAP --------------------------------------------------------------------
···
   // be run from any subfolder we can't just assume we're in the project's root.
   use folder <- result.try(find_snapshots_folder())
 
-  let new = Snapshot(title: title, content: content)
+  // 🚨 When snapping with the `snap` function we don't try and get the test
+  // info from the file it's defined in. That would require re-parsing the test
+  // directory every single time the `snap` function is called. We just put the
+  // `info` field to `None`.
+  //
+  // That additional data will be retrieved and updated during the review
+  // process where the parsing of the test directory can be done just once for
+  // all the tests.
+  //
+  // 💡 TODO: I could investigate using a shared cache or something but it
+  //          sounds like a pain to implement and should have to work for both
+  //          targets.
+  let new = Snapshot(title: title, content: content, info: None)
   let new_snapshot_path = new_destination(new, folder)
   let accepted_snapshot_path = to_accepted_path(new_snapshot_path)
 
···
   accepted: Snapshot(Accepted),
   new: Snapshot(New),
 ) -> List(DiffLine) {
-  let Snapshot(title: _, content: accepted_content) = accepted
-  let Snapshot(title: _, content: new_content) = new
+  let Snapshot(title: _, content: accepted_content, info: _) = accepted
+  let Snapshot(title: _, content: new_content, info: _) = new
   diff.histogram(accepted_content, new_content)
 }
 
 // --- SNAPSHOT (DE)SERIALISATION ----------------------------------------------
 
+fn split_n(
+  string,
+  times n: Int,
+  on separator: String,
+) -> Result(#(List(String), String), Nil) {
+  case n <= 0 {
+    True -> Ok(#([], string))
+    False -> {
+      use #(line, rest) <- result.try(string.split_once(string, on: separator))
+      use #(lines, rest) <- result.try(split_n(rest, n - 1, separator))
+      Ok(#([line, ..lines], rest))
+    }
+  }
+}
+
 fn deserialise(raw: String) -> Result(Snapshot(a), Nil) {
-  // Check there's the opening `---`
-  use #(open_line, rest) <- result.try(string.split_once(raw, "\n"))
-  use <- bool.guard(when: open_line != "---", return: Error(Nil))
-
-  // For now I have no use of the version but it might come in handy in the
-  // future if I decide to change the snapshots' metadata's format.
-  use #(version_line, rest) <- result.try(string.split_once(rest, "\n"))
-  use _version <- result.try(case version_line {
-    "version: " <> version -> Ok(version)
-    _ -> Error(Nil)
-  })
-
-  // Get the title.
-  use #(title_line, rest) <- result.try(string.split_once(rest, "\n"))
-  use title <- result.try(case title_line {
-    // We unescape the newlines
-    "title: " <> title -> Ok(string.replace(title, each: "\\n", with: "\n"))
-    _ -> Error(Nil)
-  })
-
-  // Check there's the closing `---`
-  use #(close_line, content) <- result.try(string.split_once(rest, "\n"))
-  use <- bool.guard(when: close_line != "---", return: Error(Nil))
-
-  Ok(Snapshot(title: title, content: content))
+  case split_n(raw, 4, "\n") {
+    Ok(#(["---", "version: " <> _, "title: " <> title, "---"], content)) ->
+      Ok(Snapshot(title: title, content: content, info: None))
+    Ok(_) | Error(_) ->
+      case split_n(raw, 6, "\n") {
+        Ok(#(
+          [
+            "---",
+            "version: " <> _,
+            "title: " <> title,
+            "file: " <> file,
+            "test_name: " <> test_name,
+            "---",
+          ],
+          content,
+        )) ->
+          Ok(Snapshot(
+            title: title,
+            content: content,
+            info: Some(titles.TestInfo(file: file, test_name: test_name)),
+          ))
+        Ok(_) | Error(_) -> Error(Nil)
+      }
+  }
 }
 
 fn serialise(snapshot: Snapshot(New)) -> String {
-  let Snapshot(title: title, content: content) = snapshot
+  let Snapshot(title: title, content: content, info: info) = snapshot
+  let info_lines = case info {
+    None -> []
+    Some(titles.TestInfo(file: file, test_name: test_name)) -> [
+      "file: " <> file,
+      "test_name: " <> test_name,
+    ]
+  }
+
   [
-    "---",
-    "version: " <> birdie_version,
-    // We escape the newlines in the title so that it fits on one line and it's
-    // easier to parse.
-    // Is this the best course of action? Probably not.
-    // Does this make my life a lot easier? Absolutely! 😁
-    "title: " <> string.replace(title, each: "\n", with: "\\n"),
-    "---",
-    content,
+    [
+      "---",
+      "version: " <> birdie_version,
+      // We escape the newlines in the title so that it fits on one line and it's
+      // easier to parse.
+      // Is this the best course of action? Probably not.
+      // Does this make my life a lot easier? Absolutely! 😁
+      "title: " <> string.replace(title, each: "\n", with: "\\n"),
+    ],
+    info_lines,
+    ["---", content],
   ]
+  |> list.concat
   |> string.join(with: "\n")
 }
 
···
 /// into. If it's not present the folder is created automatically.
 ///
 fn find_snapshots_folder() -> Result(String, Error) {
-  let result = result.map_error(find_project_root("."), CannotFindProjectRoot)
+  let result = result.map_error(project.find_root(), CannotFindProjectRoot)
   use project_root <- result.try(result)
   let snapshots_folder = filepath.join(project_root, birdie_snapshots_folder)
 
···
   }
 }
 
-/// Returns the path to the project's root.
-///
-/// > ⚠️ This assumes that this is only ever run inside a Gleam's project and
-/// > sooner or later it will reach a `gleam.toml` file.
-/// > Otherwise this will end up in an infinite loop, I think.
-///
-fn find_project_root(path: String) -> Result(String, simplifile.FileError) {
-  let manifest = filepath.join(path, "gleam.toml")
-  case simplifile.verify_is_file(manifest) {
-    Ok(True) -> Ok(path)
-    Ok(False) -> find_project_root(filepath.join(path, ".."))
-    Error(reason) -> Error(reason)
-  }
-}
+fn accept_snapshot(
+  new_snapshot_path: String,
+  titles: titles.Titles,
+) -> Result(Nil, Error) {
+  use snapshot <- result.try(read_new(new_snapshot_path))
+  let Snapshot(title: title, content: content, info: _) = snapshot
+  let accepted_snapshot_path = to_accepted_path(new_snapshot_path)
 
-fn accept_snapshot(new_snapshot_path: String) -> Result(Nil, Error) {
-  let accepted_snapshot_path = to_accepted_path(new_snapshot_path)
-  simplifile.rename_file(new_snapshot_path, accepted_snapshot_path)
-  |> result.map_error(CannotAcceptSnapshot(_, new_snapshot_path))
+  case titles.find(titles, title) {
+    // We could find additional info about the test so we add it to the snapshot
+    // before saving it! So we delete the `new` file and write an `accepted`
+    // one with all the new info we found.
+    Ok(titles.Literal(info)) | Ok(titles.Prefix(info, _)) -> {
+      let delete_new_snapshot =
+        simplifile.delete(new_snapshot_path)
+        |> result.map_error(CannotAcceptSnapshot(_, new_snapshot_path))
+      use _ <- result.try(delete_new_snapshot)
+
+      Snapshot(title: title, content: content, info: Some(info))
+      |> serialise
+      |> simplifile.write(to: accepted_snapshot_path)
+      |> result.map_error(CannotAcceptSnapshot(_, accepted_snapshot_path))
+    }
+
+    Error(_) ->
+      // Birdie couldn't find any additional info about the given test, so
+      // we can just move the `new` snapshot to the `accepted` one.
+      simplifile.rename_file(new_snapshot_path, accepted_snapshot_path)
+      |> result.map_error(CannotAcceptSnapshot(_, new_snapshot_path))
+  }
 }
 
 fn reject_snapshot(new_snapshot_path: String) -> Result(Nil, Error) {
···
   filepath.join(folder, file_name(snapshot.title)) <> ".new"
 }
 
-/// Strips the extension of a file (if it has one).
-///
-fn strip_extension(file: String) -> String {
-  case filepath.extension(file) {
-    Ok(extension) -> string.drop_right(file, string.length(extension) + 1)
-    Error(Nil) -> file
-  }
-}
-
 /// Turns a new snapshot path into the path of the corresponding accepted
 /// snapshot.
 ///
 fn to_accepted_path(file: String) -> String {
   // This just replaces the `.new` extension with the `.accepted` one.
-  strip_extension(file) <> ".accepted"
+  filepath.strip_extension(file) <> ".accepted"
 }
 
 // --- PRETTY PRINTING ---------------------------------------------------------
···
   let heading = fn(reason) { "[" <> ansi.bold(string.inspect(reason)) <> "] " }
   let message = case error {
     CannotCreateSnapshotsFolder(reason: reason) ->
-      heading(reason) <> "I couldn't create the snapshots folder"
+      heading(reason) <> "I couldn't create the snapshots folder."
 
     CannotReadAcceptedSnapshot(reason: reason, source: source) ->
       heading(reason)
       <> "I couldn't read the accepted snapshot from "
-      <> ansi.italic("\"" <> source <> "\"\n")
+      <> ansi.italic("\"" <> source <> "\".")
 
     CannotReadNewSnapshot(reason: reason, source: source) ->
       heading(reason)
       <> "I couldn't read the new snapshot from "
-      <> ansi.italic("\"" <> source <> "\"\n")
+      <> ansi.italic("\"" <> source <> "\".")
 
     CannotSaveNewSnapshot(
       reason: reason,
···
       <> "I couldn't save the snapshot "
       <> ansi.italic("\"" <> title <> "\" ")
       <> "to "
-      <> ansi.italic("\"" <> destination <> "\"\n")
+      <> ansi.italic("\"" <> destination <> "\".")
 
     CannotReadSnapshots(reason: reason, folder: _) ->
-      heading(reason) <> "I couldn't read the snapshots directory's contents"
+      heading(reason) <> "I couldn't read the snapshots folder's contents."
 
     CannotRejectSnapshot(reason: reason, snapshot: snapshot) ->
       heading(reason)
-      <> "I couldn't reject the snapshot"
-      <> ansi.italic("\"" <> snapshot <> "\" ")
+      <> "I couldn't reject the snapshot "
+      <> ansi.italic("\"" <> snapshot <> "\".")
 
     CannotAcceptSnapshot(reason: reason, snapshot: snapshot) ->
       heading(reason)
-      <> "I couldn't accept the snapshot"
-      <> ansi.italic("\"" <> snapshot <> "\" ")
+      <> "I couldn't accept the snapshot "
+      <> ansi.italic("\"" <> snapshot <> "\".")
 
-    CannotReadUserInput -> "I couldn't read the user input"
+    CannotReadUserInput -> "I couldn't read the user input."
 
     CorruptedSnapshot(source: source) ->
       "It looks like "
       <> ansi.italic("\"" <> source <> "\"\n")
-      <> " is not a valid snapshot.\n"
+      <> "is not a valid snapshot.\n"
       <> "This might happen when someone modifies its content.\n"
       <> "Try deleting the snapshot and recreating it."
 
-    CannotFindProjectRoot(reason: reason) ->
+    CannotFindProjectRoot(reason: reason)
+    | CannotGetTitles(titles.CannotFindProjectRoot(reason: reason)) ->
       heading(reason)
       <> "I couldn't locate the project's root where the snapshot's"
       <> " folder should be."
+
+    CannotGetTitles(titles.TestModuleIsNotCompiling(file: file)) ->
+      "The test file "
+      <> ansi.italic("\"" <> file <> "\"\n")
+      <> " is not compiling.\n"
+      <> "All your test should be compiling for Birdie to work!"
+
+    CannotGetTitles(titles.CannotReadTestDirectory(reason: reason)) ->
+      heading(reason) <> "I couldn't list the contents of the test folder."
+
+    CannotGetTitles(titles.CannotReadTestFile(reason: reason, file: file)) ->
+      heading(reason)
+      <> "I couldn't read the test file "
+      <> ansi.italic("\"" <> file <> "\"\n")
+
+    CannotGetTitles(titles.ParseError(reason: _reason)) ->
+      "I couldn't parse the content of your test modules.\n"
+      <> "This most likely is a bug in Birdie, it would be grand if you could"
+      <> "open an issue on GitHub:\n"
+      <> "\"https://github.com/giacomocavalieri/birdie/issues\""
+
+    CannotGetTitles(titles.DuplicateLiteralTitles(
+      title: title,
+      one: titles.TestInfo(file: one_file, test_name: one_test_name),
+      other: titles.TestInfo(file: other_file, test_name: other_test_name),
+    )) -> {
+      let same_file = one_file == other_file
+      let same_function = one_test_name == other_test_name
+      let location = case same_file, same_function {
+        True, True ->
+          "Both tests are defined in:\n\n  "
+          <> ansi.italic(to_function_name(one_file, one_test_name))
+        _, _ ->
+          "One test is defined in:\n\n  "
+          <> ansi.italic(to_function_name(one_file, one_test_name))
+          <> "\n\nWhile the other is defined in:\n\n  "
+          <> ansi.italic(to_function_name(other_file, other_test_name))
+      }
+
+      "It looks like there's some snapshot tests sharing the same title:
+
+  " <> ansi.italic("\"" <> title <> "\"") <> "
+
+Snapshot titles " <> ansi.bold("must be unique") <> " or you would run into strange diffs
+when reviewing them, try changing one of those.
+" <> location
+    }
+
+    CannotGetTitles(titles.OverlappingPrefixes(..)) ->
+      panic as "Prefixes are not implemented yet"
+
+    CannotGetTitles(titles.PrefixOverlappingWithLiteralTitle(..)) ->
+      panic as "Prefixes are not implemented yet"
   }
 
-  io.println_error("❌ " <> ansi.red(message))
+  io.println_error("❌ " <> message)
+}
+
+fn to_function_name(file: String, function_name: String) -> String {
+  let module_name = case file {
+    "./test/" <> rest -> filepath.strip_extension(rest)
+    _ -> filepath.strip_extension(file)
+  }
+
+  module_name <> ".{" <> function_name <> "}"
 }
 
 type InfoLine {
···
   Truncate
 }
 
+fn snapshot_default_lines(snapshot: Snapshot(status)) -> List(InfoLine) {
+  let Snapshot(title: title, content: _, info: info) = snapshot
+  case info {
+    None -> [InfoLineWithTitle(title, SplitWords, "title")]
+    Some(titles.TestInfo(file: file, test_name: test_name)) -> [
+      InfoLineWithTitle(title, SplitWords, "title"),
+      InfoLineWithTitle(file, Truncate, "file"),
+      InfoLineWithTitle(test_name, Truncate, "name"),
+    ]
+  }
+}
+
 fn new_snapshot_box(
   snapshot: Snapshot(New),
   additional_info_lines: List(InfoLine),
 ) -> String {
-  let Snapshot(title: title, content: content) = snapshot
+  let Snapshot(title: _, content: content, info: _) = snapshot
 
   let content =
     string.split(content, on: "\n")
···
       DiffLine(number: i + 1, line: line, kind: diff.New)
     })
 
-  pretty_box("new snapshot", content, [
-    InfoLineWithTitle(title, SplitWords, "title"),
-    ..additional_info_lines
-  ])
+  pretty_box(
+    "new snapshot",
+    content,
+    list.concat([snapshot_default_lines(snapshot), additional_info_lines]),
+  )
 }
 
 fn diff_snapshot_box(
···
     "mismatched snapshots",
     to_diff_lines(accepted, new),
     [
-      [InfoLineWithTitle(new.title, SplitWords, "title")],
+      snapshot_default_lines(accepted),
       additional_info_lines,
       [
         InfoLineWithNoTitle("", DoNotSplit),
···
 }
 
 fn pretty_info_line(line: InfoLine, width: Int) -> String {
-  let prefix = case line {
-    InfoLineWithNoTitle(..) -> "  "
-    InfoLineWithTitle(title: title, ..) -> "  " <> title <> ": "
+  let #(prefix, prefix_length) = case line {
+    InfoLineWithNoTitle(..) -> #("  ", 2)
+    InfoLineWithTitle(title: title, ..) -> #(
+      "  "
+      <> ansi.blue(title <> ": "),
+      string.length(title)
+      + 4,
+    )
   }
-  let prefix_length = string.length(prefix)
+
   case line.split {
     Truncate -> prefix <> truncate(line.content, width - prefix_length)
     DoNotSplit -> prefix <> line.content
···
       case new_line_length > max_length {
         True -> do_to_lines([line, ..lines], "", 0, words, max_length)
         False -> {
-          let new_line = line <> " " <> word
+          let new_line = case line {
+            "" -> word
+            _ -> line <> " " <> word
+          }
           do_to_lines(lines, new_line, new_line_length, rest, max_length)
         }
       }
···
 
 fn review() -> Result(Nil, Error) {
   use snapshots_folder <- result.try(find_snapshots_folder())
+
+  let get_titles = titles.from_test_directory()
+  use titles <- result.try(result.map_error(get_titles, CannotGetTitles))
+
   use new_snapshots <- result.try(list_new_snapshots(in: snapshots_folder))
   case list.length(new_snapshots) {
     // If there's no snapshots to review, we're done!
···
     }
     // If there's snapshots to review start the interactive session.
     n -> {
-      let result = do_review(new_snapshots, 1, n)
+      let result = do_review(new_snapshots, titles, 1, n)
       // Despite the review process ending well or with an error, we want to
       // clear the screen of any garbage before showing the error explanation
       // or the happy completion string.
···
 
 fn do_review(
   new_snapshot_paths: List(String),
+  titles: titles.Titles,
   current: Int,
   out_of: Int,
 ) -> Result(Nil, Error) {
···
       // We try reading the new snapshot and the accepted one (which might be
       // missing).
       use new_snapshot <- result.try(read_new(new_snapshot_path))
+
+      // We need to add to the new test info about its location and the function
+      // it's defined in.
+      let new_snapshot_info = case titles.find(titles, new_snapshot.title) {
+        Ok(titles.Prefix(info: info, ..)) | Ok(titles.Literal(info: info)) ->
+          Some(info)
+        Error(_) -> None
+      }
+      let new_snapshot = Snapshot(..new_snapshot, info: new_snapshot_info)
+
       let accepted_snapshot_path = to_accepted_path(new_snapshot_path)
       use accepted_snapshot <- result.try(read_accepted(accepted_snapshot_path))
 
···
       // We ask the user what to do with this snapshot.
       use choice <- result.try(ask_choice())
       use _ <- result.try(case choice {
-        AcceptSnapshot -> accept_snapshot(new_snapshot_path)
+        AcceptSnapshot -> accept_snapshot(new_snapshot_path, titles)
         RejectSnapshot -> reject_snapshot(new_snapshot_path)
         SkipSnapshot -> Ok(Nil)
       })
 
       // Let's keep going with the remaining snapshots.
-      do_review(rest, current + 1, out_of)
+      do_review(rest, titles, current + 1, out_of)
     }
   }
 }
···
   use snapshots_folder <- result.try(find_snapshots_folder())
   use new_snapshots <- result.try(list_new_snapshots(in: snapshots_folder))
 
+  let get_titles = titles.from_test_directory()
+  use titles <- result.try(result.map_error(get_titles, CannotGetTitles))
+
   case list.length(new_snapshots) {
     0 -> io.println("No new snapshots to accept.")
     1 -> io.println("Accepting one new snapshot.")
     n -> io.println("Accepting " <> int.to_string(n) <> " new snapshots.")
   }
 
-  list.try_each(new_snapshots, accept_snapshot)
+  list.try_each(new_snapshots, accept_snapshot(_, titles))
 }
 
 fn reject_all() -> Result(Nil, Error) {

src/birdie/internal/project.gleam

···
+import filepath
+import simplifile
+
+/// Returns the path to the project's root.
+///
+/// > ⚠️ This assumes that this is only ever run inside a Gleam's project and
+/// > sooner or later it will reach a `gleam.toml` file.
+/// > Otherwise this will end up in an infinite loop, I think.
+///
+pub fn find_root() -> Result(String, simplifile.FileError) {
+  do_find_root(".")
+}
+
+fn do_find_root(path: String) -> Result(String, simplifile.FileError) {
+  let manifest = filepath.join(path, "gleam.toml")
+  case simplifile.verify_is_file(manifest) {
+    Ok(True) -> Ok(path)
+    Ok(False) -> do_find_root(filepath.join(path, ".."))
+    Error(reason) -> Error(reason)
+  }
+}

src/birdie/internal/titles.gleam

···
+import gleam/bool
+import gleam/dict.{type Dict}
+import gleam/list
+import gleam/option.{None, Some}
+import gleam/result
+import gleam/string
+import filepath
+import glance
+import simplifile
+import trie.{type Trie}
+import birdie/internal/project
+
+/// A data structure to hold info about all the titles gathered from a project's
+/// test modules.
+///
+pub opaque type Titles {
+  Titles(
+    /// All the birdie literal titles defined in the module. For example:
+    /// `"This is a literal title"`
+    ///
+    literals: Dict(String, TestInfo),
+    /// All the variable titles with a constant prefix. For example:
+    /// `"snapshot number " <> int.to_string(n)`
+    ///
+    prefixes: Trie(String, TestInfo),
+  )
+}
+
+pub type TestInfo {
+  TestInfo(file: String, test_name: String)
+}
+
+/// A match you can get when looking for a title.
+///
+pub type Match {
+  Literal(info: TestInfo)
+  Prefix(info: TestInfo, prefix: String)
+}
+
+/// All the possible errors that can occur when gathering the titles from a
+/// project's test modules.
+///
+pub type Error {
+  CannotFindProjectRoot(reason: simplifile.FileError)
+  TestModuleIsNotCompiling(file: String)
+  CannotReadTestDirectory(reason: simplifile.FileError)
+  CannotReadTestFile(reason: simplifile.FileError, file: String)
+  ParseError(reason: glance.Error)
+  DuplicateLiteralTitles(title: String, one: TestInfo, other: TestInfo)
+  OverlappingPrefixes(
+    prefix: String,
+    info: TestInfo,
+    other_prefix: String,
+    other_info: TestInfo,
+  )
+  PrefixOverlappingWithLiteralTitle(
+    prefix: String,
+    prefix_info: TestInfo,
+    title_info: TestInfo,
+  )
+}
+
+type BirdieImport {
+  Unqualified(module_alias: String)
+  Qualified(module_alias: String, snap_alias: String)
+}
+
+type SnapTitle {
+  LiteralTitle(String)
+  PrefixTitle(String)
+}
+
+// --- TITLES CREATION ---------------------------------------------------------
+
+pub fn new() -> Titles {
+  Titles(literals: dict.new(), prefixes: trie.new())
+}
+
+fn add_literal_title(titles: Titles, title: String, info: TestInfo) -> Titles {
+  let literals = titles.literals
+  let new_literals = dict.insert(literals, title, info)
+  Titles(..titles, literals: new_literals)
+}
+
+// fn add_prefix_title(titles: Titles, prefix: String, info: TestInfo) -> Titles {
+//   let prefixes = titles.prefixes
+//   let new_prefixes = trie.insert(prefixes, string.to_graphemes(prefix), info)
+//   Titles(..titles, prefixes: new_prefixes)
+// }
+
+pub fn literals(titles: Titles) -> Dict(String, TestInfo) {
+  let Titles(literals: literals, prefixes: _) = titles
+  literals
+}
+
+pub fn prefixes(titles: Titles) -> Dict(String, TestInfo) {
+  let Titles(literals: _, prefixes: prefixes) = titles
+  prefixes
+  |> trie.to_list
+  |> list.map(fn(pair) {
+    let #(prefix, info) = pair
+    #(string.join(prefix, with: ""), info)
+  })
+  |> dict.from_list
+}
+
+// --- TITLE LOOKUP ------------------------------------------------------------
+
+pub fn find(titles: Titles, title: String) -> Result(Match, Nil) {
+  // We first look for exact matches.
+  let literal_match = result.map(dict.get(titles.literals, title), Literal)
+  use <- result.lazy_or(literal_match)
+
+  // If we couldn't find an exact match we look for a matching prefix.
+  let letters = string.to_graphemes(title)
+  use matching_prefixes <- result.try(trie.subtrie(titles.prefixes, letters))
+  case trie.to_list(matching_prefixes) {
+    [#(prefix, info), ..] -> Ok(Prefix(info, string.join(prefix, with: "")))
+    _ -> Error(Nil)
+  }
+}
+
+// --- TITLE GATHERING ---------------------------------------------------------
+
+pub fn from_test_directory() -> Result(Titles, Error) {
+  use root <- try(project.find_root(), CannotFindProjectRoot)
+  let test_directory = filepath.join(root, "test")
+  let get_files = simplifile.get_files(test_directory)
+  use files <- try(get_files, CannotReadTestDirectory)
+
+  use titles, file <- list.try_fold(over: files, from: new())
+  use raw_module <- try(simplifile.read(file), CannotReadTestFile(_, file))
+
+  let parse_module =
+    glance.module(raw_module)
+    |> result.replace_error(TestModuleIsNotCompiling(file))
+  use module <- result.try(parse_module)
+
+  from_module(titles, file, module)
+}
+
+pub fn from_module(
+  titles: Titles,
+  name: String,
+  module: glance.Module,
+) -> Result(Titles, Error) {
+  use birdie_import <- try_or(birdie_import(module), return: Ok(titles))
+  use titles, function <- list.try_fold(over: module.functions, from: titles)
+  let body = function.definition.body
+  use titles, expression <- try_fold_statements(body, titles)
+
+  // We see if the expression is a call to the `birdie.snap` function.
+  case snap_call(birdie_import, expression) {
+    // We have found a call to `birdie.snap` where the title is a literal
+    // string.
+    Ok(LiteralTitle(title)) -> {
+      let info = TestInfo(file: name, test_name: function.definition.name)
+      case find(titles, title) {
+        Error(Nil) -> Ok(add_literal_title(titles, title, info))
+        Ok(Prefix(prefix_info, prefix)) ->
+          Error(PrefixOverlappingWithLiteralTitle(prefix, prefix_info, info))
+        Ok(Literal(other_info)) ->
+          Error(DuplicateLiteralTitles(title, info, other_info))
+      }
+    }
+
+    // We have found a call to `birdie.snap` where the title is a constant
+    // prefix followed by some variable part.
+    Ok(PrefixTitle(_prefix)) ->
+      // TODO: I should handle prefixes but I couldn't be bothered so for now we
+      //       are ignoring those and returning the accumulator as is
+      //
+      // let info = TestInfo(file: name, test_name: function.definition.name)
+      // case find(titles, prefix) {
+      //   Error(Nil) -> Ok(add_prefix_title(titles, prefix, info))
+      //   Ok(Prefix(other_info, other)) ->
+      //     Error(OverlappingPrefixes(prefix, info, other, other_info))
+      //   Ok(Literal(title_info)) ->
+      //     Error(PrefixOverlappingWithLiteralTitle(prefix, info, title_info))
+      // }
+      Ok(titles)
+
+    // The call is in a format we do not currently support.
+    Error(Nil) -> Ok(titles)
+  }
+}
+
+fn birdie_import(module: glance.Module) -> Result(BirdieImport, Nil) {
+  use nil, import_ <- list.fold_until(over: module.imports, from: Error(Nil))
+  case import_.definition {
+    glance.Import(
+      module: "birdie",
+      alias: birdie_alias,
+      unqualified_types: _,
+      unqualified_values: unqualified_values,
+    ) -> {
+      let module_name = option.unwrap(birdie_alias, or: "birdie")
+      case imported_snap(unqualified_values) {
+        Ok(snap_alias) -> list.Stop(Ok(Qualified(module_name, snap_alias)))
+        Error(_) -> list.Stop(Ok(Unqualified(module_name)))
+      }
+    }
+    _ -> list.Continue(nil)
+  }
+}
+
+fn imported_snap(values: List(glance.UnqualifiedImport)) -> Result(String, Nil) {
+  use nil, value <- list.fold_until(over: values, from: Error(Nil))
+  case value {
+    glance.UnqualifiedImport(name: "snap", alias: None) -> list.Stop(Ok("snap"))
+    glance.UnqualifiedImport(name: "snap", alias: Some(alias)) ->
+      list.Stop(Ok(alias))
+    _ -> list.Continue(nil)
+  }
+}
+
+fn snap_call(
+  birdie_import: BirdieImport,
+  expression: glance.Expression,
+) -> Result(SnapTitle, Nil) {
+  case expression {
+    // A direct function call to the `birdie.snap` function where the first
+    // argument is the unlabelled content. This means that the second argument
+    // must be the title - labelled or not.
+    glance.Call(
+      function: function,
+      arguments: [
+        glance.Field(None, title),
+        glance.Field(Some("content"), _snapshot_content),
+      ],
+    )
+    | glance.Call(
+      function: function,
+      arguments: [glance.Field(None, _snapshot_content), glance.Field(_, title)],
+    )
+    | glance.Call(
+      function: function,
+      arguments: [
+        glance.Field(Some("content"), _snapshot_content),
+        glance.Field(_, title),
+      ],
+    )
+    | // A direct function call to the `birdie.snap` function where the first
+    // argument is the labelled title.
+    glance.Call(
+      function: function,
+      arguments: [glance.Field(Some("title"), title), glance.Field(_, _)],
+    )
+    | // A call to the `birdie.snap` function where the title is piped into it
+    // and the content is passed as a labelled argument.
+    glance.BinaryOperator(
+      name: glance.Pipe,
+      left: title,
+      right: glance.Call(
+        function: function,
+        arguments: [glance.Field(Some("content"), _snapshot_content)],
+      ),
+    )
+    | // A call to the `birdie.snap` function where the content is piped into
+    // it and the title is passed as an argument - labelled or not.
+    glance.BinaryOperator(
+      name: glance.Pipe,
+      left: _snapshot_content,
+      right: glance.Call(
+        function: function,
+        arguments: [glance.Field(_, title)],
+      ),
+    )
+    | // We pipe into `title: _`, since we're using a label we don't have to
+    // check the position.
+    glance.BinaryOperator(
+      name: glance.Pipe,
+      left: title,
+      right: glance.FnCapture(
+        function: function,
+        label: Some("title"),
+        arguments_before: _,
+        arguments_after: _,
+      ),
+    )
+    | // A call to the `birdie.snap` function where the title is piped into it
+    // and the content is passed as an argument. This must be done using a
+    // function capture.
+    glance.BinaryOperator(
+      name: glance.Pipe,
+      left: title,
+      right: glance.FnCapture(
+        function: function,
+        label: _,
+        arguments_before: [glance.Field(None, _snapshot_content)],
+        arguments_after: [],
+      ),
+    ) -> {
+      let is_snap_function = is_snap_function(function, birdie_import)
+      use <- bool.guard(when: !is_snap_function, return: Error(Nil))
+      expression_to_snap_title(title)
+    }
+    // Everything else is in a format birdie currently doesn't support.
+    _ -> Error(Nil)
+  }
+}
+
+fn is_snap_function(
+  expression: glance.Expression,
+  birdie_import: BirdieImport,
+) -> Bool {
+  let is_a_call_to_snap = fn(module, name) -> Bool {
+    case module, birdie_import {
+      None, Unqualified(module_alias: _) -> False
+      None, Qualified(module_alias: _, snap_alias: snap) -> snap == name
+      Some(module), Qualified(module_alias: birdie, snap_alias: snap) ->
+        module <> "." <> name == birdie <> "." <> snap
+      Some(module), Unqualified(module_alias: birdie) ->
+        module <> "." <> name == birdie <> ".snap"
+    }
+  }
+
+  case expression {
+    glance.Variable(name) -> is_a_call_to_snap(None, name)
+    glance.FieldAccess(glance.Variable(module), name) ->
+      is_a_call_to_snap(Some(module), name)
+    _ -> False
+  }
+}
+
+fn expression_to_snap_title(
+  expression: glance.Expression,
+) -> Result(SnapTitle, Nil) {
+  case expression {
+    glance.String(title) -> Ok(LiteralTitle(title))
+    glance.BinaryOperator(
+      name: glance.Concatenate,
+      left: glance.String(prefix),
+      right: _,
+    ) -> Ok(PrefixTitle(prefix))
+    _ -> Error(Nil)
+  }
+}
+
+// --- AST FOLDING -------------------------------------------------------------
+
+fn try_fold_statements(
+  statements: List(glance.Statement),
+  acc: a,
+  fun: fn(a, glance.Expression) -> Result(a, b),
+) -> Result(a, b) {
+  use acc, statement <- list.try_fold(over: statements, from: acc)
+  case statement {
+    glance.Use(patterns: _, function: expression)
+    | glance.Assignment(kind: _, pattern: _, annotation: _, value: expression)
+    | glance.Expression(expression) -> try_fold_expression(expression, acc, fun)
+  }
+}
+
+fn try_fold_expression(
+  expression: glance.Expression,
+  acc: a,
+  fun: fn(a, glance.Expression) -> Result(a, b),
+) -> Result(a, b) {
+  use acc <- result.try(fun(acc, expression))
+  case expression {
+    glance.Int(_)
+    | glance.Float(_)
+    | glance.String(_)
+    | glance.Variable(_)
+    | glance.Panic(_)
+    | glance.Todo(_) -> Ok(acc)
+
+    glance.NegateInt(expression)
+    | glance.NegateBool(expression)
+    | glance.FieldAccess(container: expression, label: _)
+    | glance.TupleIndex(tuple: expression, index: _) ->
+      try_fold_expression(expression, acc, fun)
+
+    glance.Block(statements) -> try_fold_statements(statements, acc, fun)
+
+    glance.Tuple(expressions) | glance.List(expressions, None) ->
+      try_fold_expressions(expressions, acc, fun)
+
+    glance.List(elements: elements, rest: Some(rest)) -> {
+      use acc <- result.try(try_fold_expressions(elements, acc, fun))
+      try_fold_expression(rest, acc, fun)
+    }
+
+    glance.Fn(arguments: _, return_annotation: _, body: statements) ->
+      try_fold_statements(statements, acc, fun)
+
+    glance.RecordUpdate(
+      module: _,
+      constructor: _,
+      record: record,
+      fields: fields,
+    ) -> {
+      use acc <- result.try(try_fold_expression(record, acc, fun))
+      use acc, #(_field, expression) <- list.try_fold(over: fields, from: acc)
+      try_fold_expression(expression, acc, fun)
+    }
+
+    glance.Call(function: function, arguments: arguments) -> {
+      use acc <- result.try(try_fold_expression(function, acc, fun))
+      try_fold_fields(arguments, acc, fun)
+    }
+
+    glance.FnCapture(
+      label: _,
+      function: function,
+      arguments_before: arguments_before,
+      arguments_after: arguments_after,
+    ) -> {
+      use acc <- result.try(try_fold_expression(function, acc, fun))
+      use acc <- result.try(try_fold_fields(arguments_before, acc, fun))
+      try_fold_fields(arguments_after, acc, fun)
+    }
+
+    glance.BitString(segments: segments) -> {
+      use acc, #(segment, options) <- list.try_fold(over: segments, from: acc)
+      use acc <- result.try(try_fold_expression(segment, acc, fun))
+      use acc, option <- list.try_fold(over: options, from: acc)
+      case option {
+        glance.SizeValueOption(expression) ->
+          try_fold_expression(expression, acc, fun)
+        _ -> Ok(acc)
+      }
+    }
+
+    glance.Case(subjects: subjects, clauses: clauses) -> {
+      use acc <- result.try(try_fold_expressions(subjects, acc, fun))
+      try_fold_clauses(clauses, acc, fun)
+    }
+
+    glance.BinaryOperator(name: _, left: left, right: right) -> {
+      use acc <- result.try(try_fold_expression(left, acc, fun))
+      try_fold_expression(right, acc, fun)
+    }
+  }
+}
+
+fn try_fold_fields(
+  fields: List(glance.Field(glance.Expression)),
+  acc: a,
+  fun: fn(a, glance.Expression) -> Result(a, b),
+) -> Result(a, b) {
+  use acc, field <- list.try_fold(over: fields, from: acc)
+  let glance.Field(item: expression, label: _) = field
+  try_fold_expression(expression, acc, fun)
+}
+
+fn try_fold_clauses(
+  clauses: List(glance.Clause),
+  acc: a,
+  fun: fn(a, glance.Expression) -> Result(a, b),
+) -> Result(a, b) {
+  use acc, clause <- list.try_fold(over: clauses, from: acc)
+  case clause {
+    glance.Clause(patterns: _, guard: None, body: body) ->
+      try_fold_expression(body, acc, fun)
+    glance.Clause(patterns: _, guard: Some(guard), body: body) -> {
+      use acc <- result.try(try_fold_expression(guard, acc, fun))
+      try_fold_expression(body, acc, fun)
+    }
+  }
+}
+
+fn try_fold_expressions(
+  expressions: List(glance.Expression),
+  acc: a,
+  fun: fn(a, glance.Expression) -> Result(a, b),
+) -> Result(a, b) {
+  use acc, expression <- list.try_fold(expressions, acc)
+  try_fold_expression(expression, acc, fun)
+}
+
+// --- UTILITIES ---------------------------------------------------------------
+
+fn try_or(result: Result(a, b), return default: c, with fun: fn(a) -> c) -> c {
+  case result {
+    Ok(a) -> fun(a)
+    Error(_) -> default
+  }
+}
+
+fn try(
+  result: Result(a, b),
+  map_error: fn(b) -> c,
+  fun: fn(a) -> Result(d, c),
+) -> Result(d, c) {
+  case result {
+    Ok(a) -> fun(a)
+    Error(e) -> Error(map_error(e))
+  }
+}

test/titles_test.gleam

···
+import gleam/dict
+import gleam/list
+import gleam/string
+import glance
+import birdie
+import birdie/internal/titles
+import gleeunit/should
+
+const module = "
+{{birdie_import}}
+
+pub fn in_pipeline_with_piped_content() {
+  some_content
+  |> in_a_pipeline
+  |> with_some_steps
+  |> {{snap_invocation}}(title: \"with label\")
+
+  some_content
+  |> in_a_pipeline
+  |> with_some_steps
+  |> {{snap_invocation}}(\"without label\")
+}
+
+pub fn in_pipeline_with_piped_title() {
+  \"with function capture and labels\"
+  |> {{snap_invocation}}(content: \"content\", title: _)
+
+  \"with function capture and some labels\"
+  |> {{snap_invocation}}(\"content\", title: _)
+
+  \"with function capture and no labels\"
+  |> {{snap_invocation}}(\"content\", _)
+
+  \"without function capture and labelled content\"
+  |> {{snap_invocation}}(content: \"content\")
+}
+
+pub fn direct_call() {
+  {{snap_invocation}}(\"content\", \"with no labels\")
+  {{snap_invocation}}(content: \"content\", title: \"with labels\")
+  {{snap_invocation}}(\"content\", title: \"with just title label\")
+  {{snap_invocation}}(\"with just content label\", content: \"content\")
+  {{snap_invocation}}(title: \"with swapped labels\", content: \"content\")
+}
+"
+
+//const module_with_prefixes = "
+//{{birdie_import}}
+//
+//pub fn in_pipeline_with_piped_content() {
+//  some_content
+//  |> in_a_pipeline
+//  |> with_some_steps
+//  |> {{snap_invocation}}(title: \"in pipeline with label\" <> x)
+//
+//  some_content
+//  |> in_a_pipeline
+//  |> with_some_steps
+//  |> {{snap_invocation}}(\"without label\" <> x)
+//}
+//
+//pub fn direct_call() {
+//  {{snap_invocation}}(\"content\", \"with no labels\" <> x)
+//  {{snap_invocation}}(content: \"content\", title: \"with labels\" <> x)
+//  {{snap_invocation}}(\"content\", title: \"with just title label\" <> x)
+//  {{snap_invocation}}(\"with just content label\" <> x, content: \"content\")
+//  {{snap_invocation}}(title: \"with swapped labels\" <> x, content: \"content\")
+//}
+//"
+
+fn assert_error(module: String) -> titles.Error {
+  let assert Ok(module) = glance.module(module)
+  let assert Error(error) =
+    titles.from_module(titles.new(), "my/module", module)
+  error
+}
+
+fn assert_titles(module: String) -> titles.Titles {
+  let assert Ok(module) = glance.module(module)
+  let assert Ok(titles) = titles.from_module(titles.new(), "my/module", module)
+  titles
+}
+
+fn pretty_titles(titles: titles.Titles) -> String {
+  let pretty = fn(title, info) {
+    let titles.TestInfo(file: file, test_name: test_name) = info
+    let title = string.pad_right(title, to: 40, with: " ")
+    let info = "[" <> test_name <> " - " <> file <> "]"
+    title <> " " <> info
+  }
+
+  let literals =
+    dict.to_list(titles.literals(titles))
+    |> list.map(fn(pair) { pretty(pair.0, pair.1) })
+    |> string.join(with: "\n")
+
+  let prefixes =
+    dict.to_list(titles.prefixes(titles))
+    |> list.map(fn(pair) { pretty(pair.0, pair.1) })
+    |> string.join(with: "\n")
+
+  "--- LITERALS ---\n" <> literals <> "\n\n--- PREFIXES ---\n" <> prefixes
+}
+
+pub fn can_find_literal_titles_when_calling_birdie_snap_test() {
+  module
+  |> string.replace(each: "{{birdie_import}}", with: "import birdie")
+  |> string.replace(each: "{{snap_invocation}}", with: "birdie.snap")
+  |> assert_titles
+  |> pretty_titles
+  |> birdie.snap(title: "can find literal titles when calling `birdie.snap`")
+}
+
+pub fn can_find_literal_titles_when_calling_snap_test() {
+  module
+  |> string.replace(each: "{{birdie_import}}", with: "import birdie.{snap}")
+  |> string.replace(each: "{{snap_invocation}}", with: "snap")
+  |> assert_titles
+  |> pretty_titles
+  |> birdie.snap(title: "can find literal titles when calling `snap`")
+}
+
+pub fn can_find_literal_titles_when_calling_aliased_birdie_snap_test() {
+  module
+  |> string.replace(each: "{{birdie_import}}", with: "import birdie as b")
+  |> string.replace(each: "{{snap_invocation}}", with: "b.snap")
+  |> assert_titles
+  |> pretty_titles
+  |> birdie.snap(title: "can find literal titles when calling aliased `b.snap`")
+}
+
+pub fn can_find_literal_titles_when_calling_aliased_snap_test() {
+  module
+  |> string.replace(
+    each: "{{birdie_import}}",
+    with: "import birdie.{snap as s}",
+  )
+  |> string.replace(each: "{{snap_invocation}}", with: "s")
+  |> assert_titles
+  |> pretty_titles
+  |> birdie.snap(title: "can find literal titles when calling aliased `s`")
+}
+
+// pub fn can_find_prefix_titles_when_calling_birdie_snap_test() {
+//   module_with_prefixes
+//   |> string.replace(each: "{{birdie_import}}", with: "import birdie")
+//   |> string.replace(each: "{{snap_invocation}}", with: "birdie.snap")
+//   |> assert_titles
+//   |> pretty_titles
+//   |> birdie.snap(title: "can find prefix titles when calling `birdie.snap`")
+// }
+//
+// pub fn can_find_prefix_titles_when_calling_snap_test() {
+//   module_with_prefixes
+//   |> string.replace(each: "{{birdie_import}}", with: "import birdie.{snap}")
+//   |> string.replace(each: "{{snap_invocation}}", with: "snap")
+//   |> assert_titles
+//   |> pretty_titles
+//   |> birdie.snap(title: "can find prexif titles when calling `snap`")
+// }
+//
+// pub fn can_find_prefix_titles_when_calling_aliased_birdie_snap_test() {
+//   module_with_prefixes
+//   |> string.replace(each: "{{birdie_import}}", with: "import birdie as b")
+//   |> string.replace(each: "{{snap_invocation}}", with: "b.snap")
+//   |> assert_titles
+//   |> pretty_titles
+//   |> birdie.snap(title: "can find prefix titles when calling aliased `b.snap`")
+// }
+//
+// pub fn can_find_prefix_titles_when_calling_aliased_snap_test() {
+//   module_with_prefixes
+//   |> string.replace(
+//     each: "{{birdie_import}}",
+//     with: "import birdie.{snap as s}",
+//   )
+//   |> string.replace(each: "{{snap_invocation}}", with: "s")
+//   |> assert_titles
+//   |> pretty_titles
+//   |> birdie.snap(title: "can find prefix titles when calling aliased `s`")
+// }
+
+pub fn we_get_an_error_for_same_literal_titles_test() {
+  "
+import birdie
+pub fn wibble_test() {
+  birdie.snap(title: \"wibble\", content: \"\")
+  birdie.snap(title: \"wibble\", content: \"\")
+}
+    "
+  |> assert_error
+  |> should.equal(titles.DuplicateLiteralTitles(
+    title: "wibble",
+    one: titles.TestInfo(file: "my/module", test_name: "wibble_test"),
+    other: titles.TestInfo(file: "my/module", test_name: "wibble_test"),
+  ))
+}
+
+pub fn can_read_the_snap_titles_from_the_project_itself_test() {
+  titles.from_test_directory()
+  |> should.be_ok
+  |> pretty_titles
+  |> birdie.snap(title: "can read the snap titles from the project itself")
+}