Calling a function inside other function

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
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
end
``````

Are you looking for this one?

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.

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

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

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

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

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.

Hi,

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

end

try do
rescue
ArgumentError -> :ok
end

|> Count.count()
|> IO.inspect()
end

def insert(s, d) do

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

:ets.lookup(dl, s)
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`.

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

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

``````(a + b)
``````

The full pipe way

``````a
|> Kernel.+(b)
``````
2 Likes

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

Some kind of clojure?

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

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

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

I was writing one last night…

``````defmodule EventStore.Core.ListenersProvider do
use GenServer
require Logger

@name __MODULE__

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

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

Thank you so much … it matters a lot.