anchor.diff:                  match loader.Grammars.Count with
                   | 0 ->
                       Log.Error("The assembly of {Path} has no precompiled grammars.", filePath)
  -                    Error()
  +                    return! Error()
                   | 1 ->
  -                    loader.Grammars.Values
  -                    |> Seq.exactlyOne
  -                    |> (fun x -> x.GetGrammar() |> Ok)
  +                    return (Seq.exactlyOne loader.Grammars.Values).GetGrammar(), filePath
                   | _ ->
                       Log.Error("The assembly of {Path} has more than one precompiled gramamr:", filePath)
                       for x in loader.Grammars.Keys do
  
positive.code: /// omitted if the file has only one precompiled grammar. The file in the first path can
  /// be either an assembly or a project file. If it is ommitted, a suitable project file
  /// will be searched in the current directory.
  type CompositePath =
      | DefaultPath
      | FileOnly of string
      | GrammarOnly of string
      | FullPath of filePath: string * grammarName: string
      static member Separator = "::"
  
  module CompositePath =
  
      let create path =
          let sep = CompositePath.Separator
          match path with
          | None -> DefaultPath
          | Some path when
              String.IsNullOrWhiteSpace(path)
              || path.AsSpan().Trim().Equals(sep.AsSpan(), StringComparison.Ordinal) -> DefaultPath
          | Some path ->
              match path.IndexOf(sep) with
              | -1 -> FileOnly path
              | 0 ->
                  let grammarName = path.Substring(sep.Length)
                  GrammarOnly grammarName
              | doubleColonPos ->
                  let filePath = path.Substring(0, doubleColonPos)
                  let grammarName = path.Substring(doubleColonPos + sep.Length)
                  FullPath(filePath, grammarName)
  
      let private resolveGrammar grammarName (filePath: string) =
          let ext = Path.GetExtension(filePath.AsSpan())
          if isProjectExtension ext then
              Log.Error("Opening projects is not currently supported")
              Error()
          elif isAssemblyExtension ext then
              use loader = new PrecompiledAssemblyFileLoader(filePath)
              match grammarName with
  
negative.code: 
                      Log.Information("You can explicitly choose the precompiled grammar you \
      want by appending {CompositePathSuffixHint} to the input file.", "'::<grammar-name>'")
                      return! Error()
              | Some grammarName ->
                  match loader.Grammars.TryGetValue(grammarName) with
                  | true, grammar -> return grammar.GetGrammar(), filePath
                  | false, _ ->
                      Log.Error("The assembly of {Path} doesn't have a precompiled grammar named {GrammarName}.", grammarName)
  
                      Log.Information("Hint: Run {CommandHint} to list all precompiled grammars of a project's assembly.", "farkle list")
                      return! Error()
          elif isGrammarExtension ext then
              return EGT.ofFile filePath, filePath
          else
              Log.Error("Unsupported file name: {FilePath}", filePath)
              return! Error()
      }
  
      let private findDefaultProject currentDir =
          Directory.EnumerateFiles(currentDir, "*.??proj", SearchOption.TopDirectoryOnly)
  