Calling a function inside other function

Questions / Help
, , ,
1

Hi,

I am having three functions and the data inputs to only one of them. Lets say i have a function A having two parameters a and b. The sum operation is going inside.

def sum(a, b), do: a + b

Then in the second function, I want to add ten to the result of sum(a, b). So i can simply do like

def sum(a, b) do 
a + b
|> add()
end

and then define add.

def add(sum) do
sum + 10
end

Now, my question is that how can I use this sum function and add functions separately. let’s say in a third function I want to take the product of sum and add function. Right now I can’t use them as the sum function is always calling the add function.

def product() do
# code here
add * sum
end
2

Are you looking for this one?

3

Actually no, I am looking for something where I can use the output of a function and also use it in some other function without specifying the arguments.

4

That sounds like OOP. Elixir doesn’t have objects. Functions act on their parameters (besides side-effects).

5

yeah, you are right … is there any approach that I can follow to get what I want …
do you think function arity can be my friend

6

I still don’t really understand what you’re after, so I can’t really give suggestions for alternatives.

7

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.

There is one way we can call function B in Function A, like this

def A(a, b, c) do
a+ b + c 
|> B()
end

But I don’t want this approach. I want to handle them separately. How you got my question.
Thanks

8

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.

9

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.

10

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

The full pipe way :slight_smile:

a 
|> Kernel.+(b) 
|> add()
2 Likes
12

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

Some kind of clojure?

13

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

14

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

15

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

16

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
1 Like
17

Thank you so much … it matters a lot.