Learn Elixir with a Rubyist, episode V

# Starting a new process can be really simple, one of the
# simplest ways is by using the `spawn/3` function.
# (`/3` specify that it expects 3 arguments)

defmodule SpawnExample do

  # This is the main funciton of this module, 
  # the one that starts our application.
  def start do
    IO.puts "============= Starting Application"

    # We call a function that is responsible for 
    # spawning our new process
    spawn_proc
  end

  # This is the function the new process is supposed to execute.
  # Once the process executes this function it will 
  # die automatically.
  def proc_func do
    IO.puts "* Started Process"
    # Wait for 1 second, for the sake of simulating some computing.
    :timer.sleep(1000)
    IO.puts "* Finished Process"
  end

  # `spawn_proc/0` is our private function (that's why we use `defp`)
  # responsible for spawning a new process.
  defp spawn_proc do

    # We spawn a new process, passing the module and the 
    # fucntion this process is supposed to execute.
    # The `__MODULE__` syntax is a reference to this own module
    # and the atom `:proc_func` indicates the function inside this
    # module that should be executed.
    # We are also sending an empty list as third argument, indicating
    # that this `proc_func` method does not expect any arguments.
    spawn(__MODULE__, :proc_func, [])
    IO.puts "============= Finishing Application"
  end
end

# Let's call on main method and see what the output will be.
SpawnExamle.start

# ============= Starting Application 
# ============= Finishing Application 
# * Started Process
# :ok
# * Finished Process
#
# Our application is executed so fast the it's finished
# before our new process is even able to print "* Started Process".
# Our new process is started in parallel and finishes only after our
# main application is already done.

# Our module definition
defmodule RecursionExample do

  # This is our main function, responsible for 
  # receiving a list, print its first element,
  # then call itself again passing the rest of the
  # list as the new argument.
  # 
  # This is accomplished thanks to the [head | tail] 
  # implementation, another Erlang feature that basically
  # enables you to separate the first element from the 
  # rest of a list. We will go back to it later.
  #
  def print_list([first_element | rest_of_the_list]) do
  	# Basically prints the first element of the list
    IO.puts first_element

    # Calls itself again, now passing what left over
    # the list as the argument
    print_list(rest_of_the_list)
  end
  
  # Here we see a function with the same name, but by
  # using pattern matching we know that it'll only
  # be called when an empty list is passed as argument,
  # therefore this will be matched by call on the function
  # above, when the all elements of the list were printed.
  #
  def print_list([]) do
  	# Prints the message indicating the execution 
  	# has finished
    IO.puts "Finished list"
  end
end


RecursionExample.print_list([1,2,3,4,5])

# Here we are able to achieve the same result in 
# a functional way. 
# You can see wee have two functions with the same name, 
# as we have done in the past, we are using pattern matching
# to define which function should be called.
# 
# 1
# 2
# 3
# 4
# 5
# Finished list

defmodule SpawnExample do
  def start do
    IO.puts "============= Starting Application"

    # Now our `spawn_proc/1` function receives one argument
    # the number of processes it's supposed to spawn.
    spawn_proc(10)
  end

  
  def proc_func do
    IO.puts "* Started Process"
    :timer.sleep(1000)
    IO.puts "* Finished Process"
  end

  # Now we will use pattern matching to implement recursion
  # into our application, this can be mind bending if
  # you haven't read the previous articles.
  #
  # This basically means that this signature of `spawn_proc/1`
  # will be matched whenever the argument sent to it is `0`
  #
  defp spawn_proc(0) do
    IO.puts "============= Finishing Application"
  end

  # As you might have noticed we have two methods with the same
  # name but different signatures, despite of both getting 
  # one argument, by using pattern matching we can be sure that
  # unless the argument is `0` this is the function that will 
  # be executed
  #
  defp spawn_proc(number_of_procs) do
    spawn(__MODULE__, :proc_func, [])
    
    # After spawning the new process, we decrease the 
    # `number_of_procs` and call this same method again, now with
    # `number_of_procs - 1` as its argument, this is a great
    # example of concurrency + recursion + patter matching.
    # When `number_of_procs - 1` is equal `0` the first `spawn_proc/1`
    # function will be called, finishing the application.
    #
    procs_missing = number_of_procs - 1
    spawn_proc(procs_missing)
  end
end

# Let's start our application and check the output
SpawnExample.start

# Again you can see our application being executed so fast
# that it finishes before our new processes are able to print
# its initial message.
# All 10 processes are started concurrently this time.
#
# ============= Starting Application
# ============= Finishing Application
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# * Started Process
# :ok
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process
# * Finished Process