Passing captured named function requiring arguments to another function?

Questions / Help
,
1

I’ve been struggling with this for a few hours now and there must be an easy answer despite my inability to search and find answers.

So I have this pretty simple code:

  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

I’m not sure how to call wait_for_true passing the captured named function tcp_port_open? that needs args.

I’ve tried a few things but they all require Mod.fun/arity or local_fun/arity. Not sure how to pass arguments into the function like so:
wait_for_true(&tcp_port_open?("localhost", 4001))

Thanks!

2

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.

1 Like
3

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
$
2 Likes
4

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!

5

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))
1 Like
6

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)
2 Likes
7

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

a capture containing at least one argument as &1

Sorry @peerreynders, You were right

8

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!