Designing for Scalability with Erlang/OTP - Ch 8 - Coffee Supervisor - Pure LFE

my-supervisor.lfe

(defmodule my-supervisor
           (export
             (start 2)
             (init 1)
             (stop 1)))

(defun start (name child-spec-list)
  "Start a supervisor with `name` and `child-spec-list`."
  (let ((pid (spawn (MODULE) 'init (list child-spec-list))))
    (register name pid)
    (tuple 'ok pid)))

(defun stop (name)
  "Stop the supervisor with `name`."
  (! name 'stop))

(defun init (child-spec-list)
  "Initialise the supervisor's process."
  (process_flag 'trap_exit 'true)
  (loop (start-children child-spec-list)))

(defun start-children (child-spec-list)
  (list-comp
    ((<- `#(,m ,f ,a) child-spec-list))
    (tuple (element 2
                    (apply m f a))
           (tuple m f a))))

(defun loop (child-list)
  (receive
    (`#(|EXIT| ,pid normal)
      (loop (: lists keydelete pid 1 child-list)))
    (`#(|EXIT| ,pid ,_reason)
      (loop (restart-child pid child-list)))
    ('stop
     (terminate child-list))))

(defun restart-child (pid child-list)
  (let* ((`#(,_pid ,`#(,m ,f ,a))
           (: lists keyfind pid 1 child-list))
         (`#(ok ,new-pid)
           (apply m f a)))
    (: lists keyreplace pid 1 child-list (tuple new-pid (tuple m f a))))))

(defun terminate (child-list)
  (: lists foreach (lambda (child)
                     (let ((`#(,pid ,_mfa) child))
                       (exit pid 'kill)))
     child-list))

Atoms that would require delimiting with single quotes in Erlang (e.g. 'EXIT') require delimiting with "pipe" characters (|) in LFE.