Why Erlang/OTP gen_server callback module must provide handle_cast function? - erlang

Question

I can understand why a callback module must provide init and handle_call functions. init is for creating the initial state, and handle_call is the main purpose for creating a server process: to serve requests.
But I don't understand why handle_cast is required. Couldn't gen_server module provide a default implementation, like it does for many other callbacks? It could be a noop like
handle_cast(_, State) -> {noreply, State}.
It seems to me that the majority of callback modules provide noops like this one anyway.

Answer 1

handle_cast is similar to handle_call, and is used for asynchronous calls to the gen_server you're running (calls are synchronous). It is handling requests for you, just not with a reply as a call does.
Similarly to gen_call it can alter the state of your gen_server (or leave it as is, up to your needs and implementation). Also it can stop your server, hibernate, etc. just like your calls - see learn you some erlang for examples and a broader explanation.
It "can be a noop" as you said in the question, but in some cases it's better to implement and handle async calls to your server.

Answer 2

and handle_call is the main purpose for creating a server process: to serve requests.
The client-server architecture can be applied to a much wider range of problems than merely a web server that serves up documents. One example is the frequency server discussed in several erlang books. A client can request a frequency from the server for making a phone call, then the client must wait for the server to give return a specific frequency before a call can be made. That is a classic gen_server:call() situation: the client must wait for the server to return a frequency before the client can make a phone call.
However, when the client is done using the frequency the client sends a message to the server telling the server to deallocate the frequency. In that case, the client does not need to wait for a response from the server because the client doesn't even care what the server's response is. The client just needs to send the deallocate message, then the client can continue executing other code. It's the server's responsibility to process the deallocate message when it has time, then move the frequency from a "busy" list to a "free" list, so that the frequency is available for other clients to use. As a result, a client uses gen_server:cast() to send a deallocate message to the server.
Now, what is the "main purpose" of the frequency server? To allocate or deallocate frequencies? If the server doesn't deallocate frequencies, then after a certain number of client requests, there won't be any more frequencies to hand out and clients will get a message that says "no frequencies available". Therefore, for the system to work correctly the act of deallocating frequencies is essential. In other words, handle_call() is not the "main purpose" of the server--handle_cast() is equally important--and both handlers are needed to keep the system running as efficiently as possible.
Couldn't gen_server module provide a default implementation, like it
does for many other callbacks?
Why can't you create a gen_server template, which has a default implementation of handle_cast() yourself? Here's emac's default gen_server template:
-behaviour(gen_server).
%% API
-export([start_link/0]).
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
-define(SERVER, ?MODULE).
-record(state, {}).
%%%===================================================================
%%% API
%%%===================================================================
%%--------------------------------------------------------------------
%% #doc
%% Starts the server
%%
%% #spec start_link() -> {ok, Pid} | ignore | {error, Error}
%% #end
%%--------------------------------------------------------------------
start_link() ->
gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).
%%%===================================================================
%%% gen_server callbacks
%%%===================================================================
%%--------------------------------------------------------------------
%% #private
%% #doc
%% Initializes the server
%%
%% #spec init(Args) -> {ok, State} |
%% {ok, State, Timeout} |
%% ignore |
%% {stop, Reason}
%% #end
%%--------------------------------------------------------------------
init([]) ->
{ok, #state{}}.
%%--------------------------------------------------------------------
%% #private
%% #doc
%% Handling call messages
%%
%% #spec handle_call(Request, From, State) ->
%% {reply, Reply, State} |
%% {reply, Reply, State, Timeout} |
%% {noreply, State} |
%% {noreply, State, Timeout} |
%% {stop, Reason, Reply, State} |
%% {stop, Reason, State}
%% #end
%%--------------------------------------------------------------------
handle_call(_Request, _From, State) ->
Reply = ok,
{reply, Reply, State}.
%%--------------------------------------------------------------------
%% #private
%% #doc
%% Handling cast messages
%%
%% #spec handle_cast(Msg, State) -> {noreply, State} |
%% {noreply, State, Timeout} |
%% {stop, Reason, State}
%% #end
%%--------------------------------------------------------------------
handle_cast(_Msg, State) ->
{noreply, State}.
%%--------------------------------------------------------------------
%% #private
%% #doc
%% Handling all non call/cast messages
%%
%% #spec handle_info(Info, State) -> {noreply, State} |
%% {noreply, State, Timeout} |
%% {stop, Reason, State}
%% #end
%%--------------------------------------------------------------------
handle_info(_Info, State) ->
{noreply, State}.
%%--------------------------------------------------------------------
%% #private
%% #doc
%% This function is called by a gen_server when it is about to
%% terminate. It should be the opposite of Module:init/1 and do any
%% necessary cleaning up. When it returns, the gen_server terminates
%% with Reason. The return value is ignored.
%%
%% #spec terminate(Reason, State) -> void()
%% #end
%%--------------------------------------------------------------------
terminate(_Reason, _State) ->
ok.
%%--------------------------------------------------------------------
%% #private
%% #doc
%% Convert process state when code is changed
%%
%% #spec code_change(OldVsn, State, Extra) -> {ok, NewState}
%% #end
%%--------------------------------------------------------------------
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
%%%===================================================================
%%% Internal functions
%%%===================================================================