Calling a function inside other function

Thank you so much … it matters a lot.

I was writing one last night…

Maybe it can help You.

defmodule EventStore.Core.ListenersProvider do
  use GenServer
  require Logger

  @name __MODULE__

  def start_link(_) do
    GenServer.start_link(@name, nil, name: @name)
  end

  def register(pid, filter_fun \\ fn _ -> true end)

  def register(pid, filter_fun) when is_function(filter_fun) do
    GenServer.call(@name, {:register, pid, filter_fun})
  end

  def unregister(pid) do
    GenServer.cast(@name, {:unregister, pid})
  end

  def get_listeners do
    @name
    |> :ets.match_object({:"$1", :"$2", :_})
    |> Enum.map(fn {pid, filter_fun, _ref} -> {pid, filter_fun} end)
  end

  def stop, do: GenServer.cast(@name, :stop)

  @impl GenServer
  def init(_) do
    Logger.debug(fn -> "#{@name} is starting}" end)
    #
    Process.flag :trap_exit, true
    :ets.new(@name, [:set, :protected, :named_table])
    {:ok, nil}
  end

  @impl GenServer
  def handle_call({:register, pid, filter_fun}, _from, _state) do
    ref = Process.monitor(pid)
    :ets.insert_new(@name, {pid, filter_fun, ref})
    {:reply, :ok, nil}
  end

  @impl GenServer
  def handle_cast({:unregister, pid}, _state) do
    case :ets.match(@name, {pid, :_, :"$1"}) do
      [[ref]] when is_reference(ref) -> Process.demonitor(ref)
      _ -> nil
    end
    :ets.delete(@name, pid)

    {:noreply, nil}
  end

  @impl GenServer
  def handle_cast(:stop, _state), do: {:stop, :normal, nil}

  @impl GenServer
  def handle_info({:DOWN, _ref, :process, pid, _status}, _state) do
    :ets.delete(@name, pid)
    {:noreply, nil}
  end

  @impl GenServer
	def terminate(reason, _state) do
    Logger.debug(fn -> "#{@name} is stopping : #{inspect reason}" end)
    #
    :ets.delete(@name)
		:ok
	end
end

i havent used processes for now. Will use in future modification.

That is why You manage an ets table with a process, You call new only once, when the server start.

I call the function every time. It helps not creating the table every time. So, if a table already exists, it skips that call.

Usually ets table are managed by a process… why are You testing if it exists in a try rescue block?

Some kind of clojure?

The full pipe way

a 
|> Kernel.+(b) 
|> add()

Hello, I can’t understand your question. Why can’t you just call add(sum(a, b), 10) where you need the result?

By the way, the following code:

a + b
|> add()

is actually a + add(b). If you really want to use pipes you need to write:

(a + b)
|> add()

Hi,

thanks for your feedback.

def delta_link(tuple, count) do
    # [{tuple, count}]

    linkv(tuple, count)
  end

  def linkv(tuple, count) do
    try do
      :ets.new(:linkv, [:named_table, :duplicate_bag])
    rescue
      ArgumentError -> :ok
    end

    :ets.insert(:linkv, [{tuple, count} | link()])

    :ets.tab2list(:linkv)
    |> Count.count()
    |> IO.inspect()
  end

  def insert(s, d) do
    dl = :ets.new(:delta_link, [:duplicate_bag])

    :ets.insert(dl, {s, d})

    :ets.lookup(dl, s)
    |> delta_link(1)
  end

in this code, i want to use delta_link separately and linkv separately. I just want to call the output of delta_link in linkv.

I want to use the output of a function A in let says function B. Sometimes we don’t have those parameters in function B, then how can we use the function A output in function B.

You can’t. If you need the output of function A you either need to call it and pass the output of it as an parameter to function B, or you need to call function A with arguments in function B.

Your question is quite theoretical, maybe you can share the problem you’re actually trying to solve (if you have a concrete thing you’re trying to achieve). Functional is a different way of programming but it can solve the same problems as OOP, it just needs a different way of thinking about the problem you want to solve.