How to implement deferred pattern in elixir?

Question

How could I implement deferred pattern in elixir?

Let me explain what it is. Let say I have some fn() which should be implemented with n seconds delay after now. But if I call this fn() second time this function should be implemented in n seconds after second call and so on. There should be a method to exit this function evaluation at all too.

You can take a look at Lodash's _.debounce function for the reference.

Answer 1

Okay here is a simplified case to get you going: here n is not in seconds but loop-steps so you are going to need big n's to see any delays. Here I use IO.puts as an example of calling a function.

defmodule myModule do
 def loop(list,count) do
   receive do
     n ->  list = list ++ n

     :die ->
        Process.exit(self(), :kill )            
   end
   if count == 0 do
     IO.puts( "timeout" )
     [head|tail] = list
     loop(tail, head) 
   else
     loop(list, count-1) 
   end
 end
end

Answer 2

In order to store state, you need a Process; a simple function won't be enough. Creating a process for this is just a few lines of code:

defmodule Debounce do
  def start_link(f, timeout) do
    spawn_link(__MODULE__, :loop, [f, timeout])
  end

  def loop(f, timeout) do
    receive do
      :bounce -> loop(f, timeout)
      :exit -> :ok
    after timeout ->
      f.()
    end
  end
end

You can send this process :bounce and it'll reset its timeout to the one specified in Debounce.start_link/2. You can also send this process :exit and it'll exit itself without running the function.

Test:

f = Debounce.start_link(fn -> IO.inspect(:executing) end, 1000)
IO.puts 1
send f, :bounce
:timer.sleep(500)

IO.puts 2
send f, :bounce
:timer.sleep(500)

IO.puts 3
send f, :bounce
:timer.sleep(500)

IO.puts 4
send f, :bounce
:timer.sleep(2000)

IO.puts 5

Output:

1
2
3
4
:executing
5

Answer 3

A very naive and simple solution could use raw processes.

defmodule Debounce do
  def start(fun, timeout) do
    ref = make_ref()

    # this function is invoked when we wait for a next application
    recur = fn recur, run ->
      receive do
        ^ref ->
          # let's start counting!
          run.(recur, run)
      end
    end

    # this function is invoked when we "swallow" next applications
    # and wait until we finally apply the function
    run = fn recur, run ->
      receive do
        ^ref ->
          # let's reset the counter
          run.(recur, run)
       after
         timeout ->
           # time is up, let's call it for real & return to waiting
           fun.()
           recur.(recur, run)
       end
    end
    pid = spawn_link(fn -> recur.(recur, run) end)
    fn -> send(pid, ref) end
  end
end

Let's see an example

iex> f = Debounce.start(fn -> IO.puts("Hello"), 5000)
iex> f.()
iex> f.()
# wait some time
Hello
iex> f.() # wait some time
Hello

However, this has many problems - our "debouncer" process effectively lives forever, we can't cancel the debounce and reliability is, at best, sketchy. We can improve, but we'll loose the return value of a simple fun that we could just call, and instead we'll need to call a special function to "apply" our debouncer.

defmodule Debounce do
  def start(fun, timeout) do
    ref = make_ref()

    # this function is invoked when we wait for a next application
    recur = fn recur, run ->
      receive do
        {^ref, :run} ->
          # let's start counting!
          run.(recur, run)
        {^ref, :cancel} ->
          :cancelled
      end
    end

    # this function is invoked when we "swallow" next applications
    # and wait until we finally apply the function
    run = fn recur, run ->
      receive do
        {^ref, :run} ->
          # let's reset the counter
          run.(recur, run)
        {^ref, :cancel} ->
          :cancelled
       after
         timeout ->
           # time is up, let's call it for real & return to waiting
           fun.()
           recur.(recur, run)
       end
    end
    pid = spawn_link(fn -> recur.(recur, run) end)
    {pid, ref}
  end

  def apply({pid, ref}) do
    send(pid, {ref, :run})
  end

  def cancel({pid, ref}) do
    send(pid, {ref, :cancel})
  end
end

Let's see an example:

iex> deb = Debounce.start(fn -> IO.puts("Hello"), 5000)
iex> Debounce.apply(deb)
iex> Debounce.apply(deb)
# wait some time
Hello
iex> Debounce.apply(deb)
iex> Debounce.cancel(deb)
# wait some time
# nothing

This still has some possible corner cases - a production version would probably use a Task or a GenServer.