Functional Core Imperative Shell

1.procedureal_feeding_time.rb

def feeding_time
  walruses.each do |walrus|  /* we know how to destructure walruses array */
    walrus.stomach << Cheese.new  /* we know the deep structure of a walrus object */
  end
end

2.OO_feeding_time.rb

def feeding_time
  walruses.each do |walrus|  /* we still know how to destructure walruses array*/
    walrus.eat(Cheese.new) /* but we dont know the deep structure of walrus */
  end
end

class Walrus
  def eat(food)
    @stomach << food
  end
end

3.Functional_feeding_time.rb

/* walrus is a primitive, e.g. a struct */

def feeding_time
  walruses.map do |walrus| /* map does not mutate walruses array, it creates new array of walruses*/
    eat(walrus, "cheese")
  end
end

/* this method does not mutate the input walrus, it creates a new walrus*/
def eat(walrus, food)
  stomach = walrus.fetch(:stomach) + [food]  /* new stomach */
  walrus.merge(:stomach => stomach) /*new walrus */
end

4.NewParadigm_feeding_time.rb

def feeding_time
  walruses.map do |walrus|
    walrus.eat(walrus, "cheese") /* Compared to OO: this eat method returns a new walrus, it does NOT mutate the walrus object */
  end
end

/*Compared to Functional: eat method constructs a new object, instead of a primitive */
class Walrus
  def eat(food)
    Walrus.new(@name, @stomach + [food]) /* returns new walrus instead of mutating @stomach of the current Walrus */
  end
end

4.note.md

Functional Core

Functional cores make decisions (many code paths), but has every few dependencies (very well isolated)

Imperative Shell

Compose functional cores (many depencenies), but makes very few decisions (very few code paths).

Notes

1. Buidling app around concepts of imperative shells and functional cores is like doing OO with Functional computations.