How to communicate between different case situation in erlang case - erlang

Question

I'm trying to do something like this:
test(Tester) ->
case Tester of
start -> X = 4
ok -> X = X + 5,
Y = X/5;
terminate -> Y
end.
But not exactly this. I Know it can be achieved with tail or simple recursion.
normally X and Y are unbound.
Is there any way to communicate between these cases without the usage of erlang global variables?

Answer 1

Erlang is a functional language it means we don't communicate between different parts of the code or store values in variables without purpose, we just compute to return value (and sometimes make some sideeffect). If we have common computation in different branches of code we can simply place it in common function.
test(Tester) ->
case Tester of
start -> 4;
ok -> computeY();
terminate -> computeY()
end.
computeY() ->
X = 4 + 5,
X/5.

Answer 2

If you need to access a variable in any clause body of a case statement, You have to assign it before case statement or sometimes you can assign it in case clause pattern:
test(Arg) ->
Size = get_size(Arg), % I will use 'Size' in each clause body
case Arg of
#{foo := Foo} -> % if Arg is an Erlang map and has key 'foo'
% I can use 'Foo' only here:
io:format("It's a map with size ~p and has key foo with value ~p\n", [Size, Foo]);
[Baz|_] -> % if Arg is an Erlang list with at least one element
% I can use 'Baz' only here and for example i can NOT use 'Foo' here:
io:format("It's a list with size ~p and its first element is ~p\n", [Size, Baz]);
_ ->
io:format("Unwanted argument ~p with ~p size\n", [Arg, Size])
end.
get_size(X) when is_map(X) -> map_size(X);
get_size(X) when is_list(X) -> length(X);
get_size(_) -> unknown.
I put above code in an Erlang fun named Test to using it in shell without need to compile a module file:
1> Test([5,4,3,2,1]).
It's a list with size 5 and its first element is 5
ok
2> Test(#{key => value, foo => ':)'}).
It's a map with size 2 and has key foo with value ':)'
ok
3> Test([]).
Unwanted argument [] with 0 size
ok
4> Test(#{key => value}).
Unwanted argument #{key => value} with 1 size
ok
5> Test(13).
Unwanted argument 13 with unknown size
ok
If you are curious about variable binding in case, I recommend to read this article

Answer 3

To do this in Erlang you would start (spawn) a process that would hold X in memory as well as the PID (process id) of the process it is supposed to reply to unless you want to pass it a different PID every time along with start/ok/terminate. Processes in Erlang have their own memory, state or loopData. After you spawn a process that knows how to handle specific messages, you pass it the messages and it replies by sending a message back.
start_test() ->
TestPID = spawn(?MODULE, test, [self()]),
TestPID ! start,
receive
X -> io:format("X is: ~p~n",[X]
end,
TestPID ! ok,
receive
{X,Y} -> io:format("X is: ~p, Y is: ~p~n",[X, Y]
end,
TestPID ! terminate,
receive
Y -> io:format("Y is: ~p~n",[Y]
end.
test(PID) ->
receive
start -> PID ! 4,
test(4, undefined, PID);
terminate -> undefined
end.
test(X, Y, PID) ->
receive
ok -> PID ! {X+5, (X+5)/5},
test(X+5, (X+5)/5, PID);
terminate -> PID ! Y
end.
Don't forget to create a module and export start_test/0 and test/1
If you run start_test() you should get an output of
X is: 4
X is: 9, Y is: 1.8
Y is: 1.8