Learn Modern Erlang for Python and Javascript Developers

-module(guess).
%% Exporting functions makes them public. Format is [function_name/arity].
-export([start/0]).

start() ->
    %% Generate a random number from 1 to 100
    Secret = rand:uniform(100),
    %% ~n is the newline character in Erlang format strings
    io:format("Guess the number between 1 and 100!~n"),
    %% Instead of a while loop, we call a recursive function
    loop(Secret).

loop(Secret) ->
    %% io:fread reads formatted input. "~d" expects an integer.
    %% It returns a tagged tuple like {ok, [Number]} or {error, Reason}.
    case io:fread("> ", "~d") of
        %% The 'when' clause is called a Guard. It adds logic to pattern matching.
        {ok, [Guess]} when Guess < Secret ->
            io:format("Higher!~n"),
            loop(Secret);  %% Recurse
            
        {ok, [Guess]} when Guess > Secret ->
            io:format("Lower!~n"),
            loop(Secret);
            
        {ok, [_Guess]} ->
            %% We matched the integer, and it wasn't > or <, so it must be ==
            io:format("You win!~n");
            
        %% The underscore acts as a wildcard catch-all
        _ ->
            io:format("Please type a valid number!~n"),
            loop(Secret)
    end.

-module(arithmetic).
-export([start/0]).

start() ->
    io:format("Solve the addition problems! Type 'quit' to exit.~n"),
    play_loop().

play_loop() ->
    A = rand:uniform(10),
    B = rand:uniform(10),
    
    %% ~p prints Erlang terms. We prompt the user using io:get_line.
    Input = io:get_line(io_lib:format("What is ~p + ~p? ", [A, B])),
    
    %% We strip the newline character and handle the routing
    CleanInput = string:trim(Input),
    handle_input(CleanInput, A + B).

%% Erlang allows you to define multiple "clauses" for the same function.
%% The compiler checks them top-to-bottom to see which pattern matches.

%% Clause 1: The user typed "quit"
handle_input("quit", _CorrectAnswer) ->
    io:format("Thanks for playing!~n");

%% Clause 2: Anything else, we try to convert it to an integer
handle_input(StringInput, CorrectAnswer) ->
    try list_to_integer(StringInput) of
        CorrectAnswer -> 
            io:format("Correct!~n"),
            play_loop();  %% Loop back
        _WrongAnswer -> 
            io:format("Wrong! It was ~p.~n", [CorrectAnswer]),
            play_loop()
    catch
        error:badarg ->
            io:format("Please enter a number or 'quit'.~n"),
            play_loop()
    end.

-module(counter).
-export([start/0, loop/1]).

start() ->
    %% spawn/3 creates a new process and returns its Process ID (PID).
    %% This process takes microseconds to create and uses almost no memory.
    Pid = spawn(?MODULE, loop, [0]),
    io:format("Counter started with PID: ~p~n", [Pid]),
    Pid.

%% This function runs infinitely in its own process
loop(Count) ->
    %% 'receive' blocks the process until a message arrives in its mailbox
    receive
        {add, Amount} ->
            NewCount = Count + Amount,
            io:format("Counter is now: ~p~n", [NewCount]),
            %% Recurse with the new state
            loop(NewCount);
            
        {get, CallerPid} ->
            %% Send (!) the current count back to the caller
            CallerPid ! {current_count, Count},
            %% State hasn't changed, recurse with the same Count
            loop(Count);
            
        stop ->
            io:format("Stopping counter.~n"),
            ok %% Process naturally dies when the function ends
    end.

%% Usage in REPL:
%% Pid = counter:start().
%% Pid ! {add, 5}.
%% Pid ! stop.