How to invoke a tail-call loop expression like Clojure's loop?

Without defining a function, is there an equivalent of Clojure’s loop or Scheme’s named let where I can run a tail-call loop expression while accumulating multiple values?
There’s Enum.reduce, but the number of iterations may not known in advance, and carrying multiple accumulated values with reduce is clunky.

Thank you in advance.

Edit: provided my concrete usage in reply.

1 Like

Often there are multiple ways to solve one problem. You need to give an example of what you want to do including example input, output and what you tried so far, before anybody would give you a satisfying solution.


I am writing an Elixir script version of Merge pdf files and automatically create a table of contents with each file as an entry

At the step of bookmark (TOC) generation, we need to iterate through the list of input files, while keeping page_counter increasing and the accumulated bookmarks (not necessarily as we can append to the file at each step but I prefer to write at once).

Current Elixir version: make use of reduce, it works but doensn’t look ideal.

bookmark_content =
    {1, ""},
    fn file, {cur_page_num_counter, acc_bookmarks} ->
      IO.puts("Generating bookmarks for '#{file}'")
      # Title: base name with "_" replaced by " "
      title = Path.basename(file, '.pdf') |> String.replace("_", " ")
      cur_file_bookmarks = "BookmarkBegin
BookmarkTitle: #{title}
BookmarkLevel: 1
BookmarkPageNumber: #{cur_page_num_counter}
      new_page_num_counter = cur_page_num_counter + page_number_in_file.(file)

      # Demote file's bookmarks' levels, so that they appear under the current
      # file
      demoted_bookmarks_of_current =
        shell_command_to_string.("pdf-my-demote-bookmarks '#{file}' #{cur_page_num_counter - 1}")

      new_bookmarks = acc_bookmarks <> cur_file_bookmarks <> demoted_bookmarks_of_current
      {new_page_num_counter, new_bookmarks}
  |> elem(1)

An Emacs Lisp version may look like this (making use of

(named-let recur ((files input-files)
                  (cur-page-num-counter 1)
                  (acc-bookmarks ""))
   ((seq-empty-p files)
    (-let* ((file (car files))
            (title (--> (file-name-base file)
                        (string-replace "_" " " it)))
            (cur-file-bookmarks (format "BookmarkBegin
BookmarkTitle: %s
BookmarkLevel: 1
BookmarkPageNumber: %d
" title cur-page-num-counter))
            (new-page-num-counter (+ cur-page-num-counter
                                     (page-number-in-file file))))
      (message "Generating bookmarks for %s" file)
      (recur (cdr files)
             (concat acc-bookmarks
                      (format "pdf-my-demote-bookmarks %s %s"
                              (- cur-page-num-counter 1)))))))))

(gist link cause I couldn’t see this with syntax highlighting when replying
pdf-toc-gen.el · GitHub )

Your Elixir code looks good to me, what’s your issue with it?

One thing I’d change is make it more obvious what part of a tuple you’re getting at the end e.g. not use elem but the then construct – just to make it little more readable.

But other than that the code looks good IMO.


Having 2-element Tuple as acc is not a shame. Many reduce-based solutions written by senior developers are using it. Your code is really good enough. :+1:

However there is other way to write same code. You can use a simple pattern matching solution, for example:

defmodule Example do
  # function header with default arguments
  def sample(files, bookmarks \\ "", counter \\ 1)

  # when done return only bookmarks string
  def sample([], bookmarks, _counter), do: bookmarks

  # tail recursion
  def sample([file | files], acc_bookmarks, acc_counter) do
  	# your logic goes here, for example
  	{file_bookmarks, file_counter} = process_file(file)
  	# recursively call this for rest files with updated bookmarks and counter
  	sample(files, acc_bookmarks <> file_bookmarks, acc_counter + file_counter)

Personally I like separating accumulation and process logic, as in example above, which makes the code more clear.