Passing captured named function requiring arguments to another function?

I would pass function and arguments to wait_for_true. In fact, I would pass a mfa form… if there is a named module.

eg.

defmodule Blah do
  def tcp_port_open?(host, port) do
    case :gen_tcp.connect(String.to_charlist(host), port, []) do
      {:ok, socket} ->
        :gen_tcp.close(socket)
        true

      {:error, _} ->
        false
    end
  end

  def wait_for_true(module, fun, arg), do: do_wait(module, fun, arg, 10_000)

  defp do_wait(_module, _fun, _arg, 0), do: false
  defp do_wait(module, fun, arg, timeout) do
    case apply(module, fun, arg) do
      true ->
        true
      false ->
        :timer.sleep(100)
        do_wait(module, fun, arg, max(0, timeout - 100))
    end
  end
end

Then call it like this

Blah.wait_for_true(Blah, :tcp_port_open?, ["localhost", 4001])

BTW I am not sure I would choose such solution for retry… Probably a process, and/or gen_retry.

You need to create a separate closure.

defmodule Demo  do

  def fun(limit, max) do
    value = :rand.uniform(max)
    cond do
      value <= limit ->
       IO.write("#{value}, ")
       false
      true ->
        IO.puts("#{value}")
        true
    end
  end

  def make_fun(limit, max) do
    fn() -> Demo.fun(limit, max) end
  end

  def make_fun2(f, limit, max) do
    fn() -> f.(limit, max) end
  end

  def make_fun3(m, f, limit, max) do
    fn() -> Kernel.apply(m, f, [limit, max]) end
  end

  def wait_for_true(fun), do: wait_for_true(fun, 10_000)
  def wait_for_true(_fun, 0), do: false
  def wait_for_true(fun, timeout) do
    case fun.() do
      true ->
        true

      false ->
        :timer.sleep(100)
        wait_for_true(fun, max(0, timeout - 100))
    end
  end

end

Demo.wait_for_true(fn() -> Demo.fun(80,100) end)
Demo.wait_for_true(Demo.make_fun(80,100))
Demo.wait_for_true(Demo.make_fun2(&Demo.fun/2, 80, 100))
Demo.wait_for_true(Demo.make_fun3(Demo, :fun, 80, 100))

$ elixir demo.exs
24, 52, 39, 2, 12, 18, 88
68, 76, 32, 90
73, 66, 58, 1, 20, 46, 61, 72, 76, 62, 51, 43, 5, 15, 38, 58, 39, 5, 94
36, 39, 12, 79, 45, 69, 68, 84
$ 

Hi @kokolegorille,

Thanks for the suggestion.. I will give it a try when back at my laptop but looks like it should work great.

I didn’t want to spawn another process or use gen_retry since I wanted my test process/thread to block until the TCP port is open (or 10 seconds has elapsed… when the timeout will cause an exception). Basically this is to avoid a race condition while testing a nodejs endpoint which needs to be up before I can start running the tests. I think this is a good way to wait but please let me know if I am off-base.

Thanks!

But there is already a clojure with &

You could have written

Demo.wait_for_true(& Demo.fun(80,100))

And so the code would have worked with a named module

defmodule Blah do
  def tcp_port_open?(host, port) do
    case :gen_tcp.connect(String.to_charlist(host), port, []) do
      {:ok, socket} ->
        :gen_tcp.close(socket)
        true

      {:error, _} ->
        false
    end
  end

  def wait_for_true(fun), do: wait_for_true(fun, 10_000)
  def wait_for_true(_fun, 0), do: false
  def wait_for_true(fun, timeout) do
    case fun.() do
      true ->
        true

      false ->
        :timer.sleep(100)
        wait_for_true(fun, max(0, timeout - 100))
    end
  end
end

If called like this

Blah.wait_for_true(& Blah.tcp_port_open?("localhost", 4001))

If they were to just do & Blah.tcp_port_open?("localhost", 4001) it would fail.

Here’s an example with the error that explains why:

iex(1)> x = & IO.puts("hi")
** (CompileError) iex:1: invalid args for &, expected an expression in the format of &Mod.fun/arity, &local/arity or a capture containing at least one argument as &1, got: IO.puts("hi")

Basically, a captured function always needs to be able to receive one argument. It can be fixed by wrapping the call in a fn:

Blah.wait_for_true(fn ->
  Blah.tcp_port_open?("localhost", 4001)
end)

Oh Yes, That really requires one argument at least, thanks for spotting, again

a capture containing at least one argument as &1

Sorry @peerreynders, You were right

Thanks, this works. I knew it would be a simple fix. I had been messing with trying to capture the named function with & for hours and didn’t even think to simply wrap it in a fn -> end.

Not sure why captured/anonymous functions still trip me up sometimes!