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
$ 

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.

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