leafboi

       O
      / \
     B   A
    /     \
   C   |   D

   const x = 1
   def g(n):
       return n + x

   def g(n):
      return n + 1

  namespace myNameSpace {
     def add(x, y):
        return x + y
  }
  
  def add(x, y):
      return x + y

  print(myNameSpace.add(1,2))
  print(add(1, 2))

  def myNameSpaceadd(x, y):
     return x + y

  def add(x, y):
     return x + y

  print(myNameSpaceadd(x, y))
  print(add(1,2))

   module B{
      def g(x):
         return (x + 1) * 2
   }

   module A{
      def c(x):
         return A.g(x)*4
   }

  module B{
     def g(x):
         return h(f(x))

     //requires find and place refactor for all usages in module B. 
     def new_g(x):
         return z(f(x))

     //decomposition of g
     def f(x):
        return x + 1

     def h(x):
        return x * 2

     //new behavior
     def z(x):
        return x * 3

  }

  module A{
     def c(x):
       return A.g(x)*4
  }

  class A:
     def constructor:
         //does a bunch of random shit

     def someMethodThatMutatesSomething() -> output




   class B:

       def someOtherFunctionThatNeedsClassA:
           //cannot call someMethodThatMutatesSomethingwithout doing "a bunch of random shit" or even possibly modifying or breaking something else. Modularity is harder to achieve with this pattern. 

   def somePureFunctionWithNoSideEffects(input) -> output

   int add(x: int, y: int)

  object.verb(parameter)

  verb(object, parameter)

  object.setter()

  def add(x, y):
     doublex = x * 2
     doubley = y * 2
     return doubley + doublex

  def add(x, y):
     return y * 2 + x * 2

  add x y = let doublex = x * 2,
                doubley = y * 2
            in doubley + doublex

  add x y = (y * 2) + (x * 2)

  add = (acc, x) => x + acc
  m = reduce(add, [1,2,3])

  m => 6

  m = [1,2,3]
  acc = 0
  for(int i = 0; i < m.length; i++){
     acc += m[i]
  }

  acc => 6