Comp  sition

James Dabbs

jamesdabbs

Composition

Composition

Category Theory

Lessons Learned

Category Theory

Lessons Learned

Category Theory

Lessons Learned

• Literally: same shape
• Two things that may appear different, but function identically

Category Theory

Lessons Learned

Commutative Diagrams

Category Theory

Lessons Learned

Abstraction

• Abstraction is the process of unifying concepts by ignoring their differences
• You often know you're at the right level of abstraction when there's only one thing that could possibly work (and that thing works)
• Function composition is a surprisingly robust abstraction

Object Composition

• In OO, composition refers to an object holding a reference to one or more other objects that it collaborates with to fulfill its responsibilities
• has-a relationship (as opposed to inheritance's is-a)

Object Composition

class Topologist
  attr_reader :jokes

  def initialize jokes:
    @jokes = jokes
  end

  def tell_joke
    @jokes.sample
  end
end

Object Composition

class AlgebraicTopologist < Topologist
  def tell_joke
    @jokes.select { |joke| gets? joke }.sample
  end

  private

  def gets? joke
    joke.length < 200 || joke.include?("group")
  end
end

Object Composition

class LoudTopologist < Topologist
  def tell_joke
    super.upcase + "!!!"
  end
end

Object Composition

class LoudAlgebraicTopologist < ??
end

Object Composition

class Algebraist
  def initialize topologist
    @topologist = topologist
  end

  def tell_joke
    @topologist.jokes.shuffle.find { |joke| gets? joke }
  end

  private

  def gets?(joke); ...; end
end

Object Composition

class Loudspeaker
  def initialize jokester
    @jokester = jokester
  end

  def tell_joke
    @jokester.tell_joke.upcase + "!!!"
  end
end

• Collaborating objects allow us to parameterize behavior
• We do not need a distinct class for each combination of behaviors

topologist                = Topologist.new jokes: Topologist::JOKES
algebraic_topologist      = Algebraic.new topologist
loud_topologist           = Loudspeaker.new topologist
loud_algebraic_topologist = Loudspeaker.new algebraic_topologist

Observations

• This is still brittle because of the inconsistent API between objects
• This is far from the only way to design the API of these objects

topologist = Topologist.new jokes: Topologist::JOKES
error      = Algebraic.new Loudspeaker.new topologist

puts error.tell_joke

# => ...

Observations

Function Composition

Function Composition

f :: Int -> Int
f x = x + 2

g :: Int -> Int
g x = x**2

(f . g) 3 = f (g 3) = f 9 = 11

Consider

Advantages

Pure

Advantages

Pure Data-in, data-out

• No implicit dependencies
• Easy to test and trust
• Easy to parallelize

Advantages

Equational reasoning

f x = x + 2

g (f x) = g (x + 2)

Advantages

Tansparent composition

f :: A -> B
g :: B -> C

g . f  :: A -> C
f >> g :: A -> C

>> :: (A -> B) -> (B -> C) -> (A -> C)

• Functions always have one input type and one output type
• Functions are composable whenever their output and input types match up

Topologists in Haskell

Topologists in Haskell

algebraicTopologist :: [String] -> String
algebraicTopologist jokes = (filter gets >> shuffle >> head) jokes
  where
    gets joke = length joke < 200 || isInfixOf "group" joke

Topologists in Haskell

topologist          = filter (\_ -> True) >> shuffle >> head
algebraicTopologist = filter gets         >> shuffle >> head

algebraicTopologist :: [String] -> String
algebraicTopologist jokes = (filter gets >> shuffle >> head) jokes
  where
    gets joke = length joke < 200 || isInfixOf "group" joke

algebraicTopologist = filter gets >> shuffle >> head
  where
    gets joke = ...

But wait ...

Topologists in Haskell

filter isFunny >> shuffle >> head

Topologists in Haskell

loudTopologist = shuffle >> head >> shout
  where
    shout str = upcase str ++ "!!!"

-- or, equivalently
loudTopologist = topologist >> shout

Topologists in Haskell

makeTopologist :: SenseOfHumor -> Delivery -> Topologist

Topologists in Haskell in Ruby

double :: Int -> Int
double x = x * 2

Topologists in Haskell in Ruby

makeTopologist :: (String -> Bool) -> (String -> String) -> [String] -> String
makeTopologist isFunny delivery = filter isFunny >> shuffle >> head >> delivery

Topologists in Haskell in Ruby

makeTopologist :: SenseOfHumor -> Delivery -> Topologist

Topologists in Haskell in Ruby

makeTopologist :: SenseOfHumor -> Delivery -> Topologist

class Topologist
  attr_reader :sense_of_humor, :delivery

  def initialize sense_of_humor:, delivery:
    @sense_of_humor, @delivery = sense_of_humor, delivery
    freeze
  end

  def call jokes
    delivery.call jokes.select { |joke| sense_of_humor.call joke }.sample
  end
end

Topologists in Haskell in Ruby

makeTopologist :: SenseOfHumor -> Delivery -> Topologist

class Topologist
  def with overrides={}
    self.class.new({
      sense_of_humor: sense_of_humor,
      delivery:       delivery
    }.merge overrides)
  end
end

Topologists in Haskell in Ruby

class SenseOfHumor
  def initialize word:, max_length:
    @word, @max_length = word, max_length
    freeze
  end

  def call joke
    joke.length < @max_length || joke.include?(@word)
  end
end

Embedded Haskell

Rules Guidelines for functional Ruby

• Objects should have a defined collection of fields. An object's state should be expressible entirely in terms of those fields.
• Fields should be set at initialization and then frozen. "Updates" are performed by creating a new object.
• Objects should respond to call to perform their (primary) responsibility.

Embedded Haskell

Advantages

In this system, our objects

• have a clearly defined responsibility
• have a predictable interface
• are immutable
• have injectable dependencies
• are easy to configure and re-configure
• are easy to test
• are easy to mock in tests

In Ruby

you already think about types and composition

def create_post request
  post = parse_input request
  id   = persist post
  success_with_id id
end

In Ruby

you already think about duck types and composition

def create_post request
  post = parse_input request
  id   = persist post
  success_with_id id
end

def persist obj
  obj.save!
  obj.id
end

In Ruby

you already think about duck types and composition

def create_post request
  post = parse_input request
  id   = persist post
  success_with_id id
end

def persist obj
  if valid? obj
    obj.save
    obj.id
  end
end

Embedded Haskell

Testing

class Multiples
  fields :factor
  
  def call count
    1.upto(count).map { |i| i * factor }
  end
end

Embedded Haskell

Testing

class Bot
  fields :handlers,    # :: [Handler]
         :dispatcher,  # :: [Handler] -> Message -> Handler
         :http         # :: Request -> Nil

  def call request; ...; end  
end

let(:bot)     { Bot.new ... } # or a "live" production Bot configuration
let(:message) { Message.new text: "hello", user: ... }

Embedded Haskell

Testing

Possible considerations

• Given an input, expect an output
• Need a dependency to produce a particular value
• Need a dependency to receive a particular value

Embedded Haskell

Testing

# 1) Input => Output
response = bot.with(
  http: ->(req) { }
).call message

# 2) Dependecy returns a particular value
response = bot.with(
  dispatcher: ->(reqs, msg) { TestHandler.new }
).call message

# 3) Dependency receives a particular value
http = double "HTTPClient"
expect(http).to receive(...)

response = bot.with(http: http).call message

expect(response.text).to eq "..."

Example - Medlink

class SMS::OrderPlacer
  def initialize sms
    @sms = sms
  end

  def run!
    parse_message
    build_order
    validate_order
    record
    send_response
  end

  private

  # ...
end

Example - Medlink

class SMS::OrderPlacer
  def initialize sms
    @sms = sms
  end

  def run!
    parse_message
    build_order
    validate_order
    record
    send_response
  end

  private

  def parse_message
    @user = something_involving @sms
    @text = something_else_involving @sms
  end

  def send_response
    Medlink.notifier.notify "#{@user} has ordered #{@order.supplies.to_sentence}"
  end

  # ...
end

When composition is implicit, so are boundaries

Example - Composed

class SMS::OrderPlacer
  fields :notifier, :db

  def call sms
    send_response( record( validate_order( build_order( parse_message( sms )))))
  end

  private

  def parse_message sms
  ...
end

Example - Composed

class SMS::OrderPlacer
  fields :notifier, :db

  def call sms
    compose(
      :parse_message, 
      :build_order, 
      :validate_order, 
      :record, 
      :send_response
    ).call sms
  end

  def compose *methods
    ->(val) do
      result = val
      methods.each do |name|
        result = method(name).call result
      end
      result
    end
  end
end

Example - Composed

class SMS::OrderPlacer
  fields :notifier, :db

  def call sms
    compose(
      :parse_message, 
      :build_order, 
      :validate_order, 
      :record, 
      :send_response
    ).call sms
  end

  def compose *methods
    ->(val) do
      methods.reduce(val) do |result, name|
        method(name).call result
      end
    end
  end
end

Example - Composed

class SMS::OrderPlacer
  fields :notifier, :db

  def call sms
    compose(:parse_message, :build_order, :validate_order, 
      :record, :send_response).call sms
  end

  def parse_message sms
    ParseResult.new user: ..., text: ...
  end

  def record order
    db.save_order order
    order
  end

  def send_response order
    notifier.call "#{order.user} has ordered #{order.supplies.to_sentence}"
    "Got it! Your #{order.supplies.to_sentence} are on the way"
  end

  # ...
end

Example - Composed

placer = Medlink.container.sms_order_placer.with(
  db:       instance_double(Medlink::Repository),
  notifier: ->(_) { nil }
)

expect(placer.db).to receive(:save_order)

message = Message.new(
  text: "Order bandages, mosquito netting - please and thank you!",
  user: ...
)
response = placer.call message
expect(response).to eq \
  "Got it! Your bandages and mosquito netting are on the way!"

Example - Extracted

class SMS::OrderPlacer
  fields :notifier, :db, :order_placer

  def call sms
    compose(:parse_message, :build_order, order_placer).call sms
  end

  def compose *methods
    ->(val) do
      methods.reduce(val) do |result, m|
        func = m.respond_to?(:call) ? m : method(m)
        func.call result
      end
    end
  end
end

Example - Extracted

class OrderPlacer
  fields :notifier, :db

  def call order
    compose(:validate_order, :record, :send_response).call sms
  end

  private

  # other methods extracted from SMS::OrderPlacer ...
end

parse_message  :: SMS         -> ParseResult
build_order    :: ParseResult -> Order
validate_order :: Order       -> Order
record         :: Order       -> Order
send_response  :: Order       -> String

sms_order_placer :: SMS -> String

Example - Maybe

-- Maybe Type ~> Type | nil
parse_message  :: SMS         -> Maybe ParseResult
build_order    :: ParseResult -> Maybe Order
validate_order :: Order       -> Maybe Order
record         :: Order       -> Maybe Order
send_response  :: Order       -> Maybe String

sms_order_placer :: SMS -> Maybe String

Example - Maybe

Example - Maybe

-- Maybe Type ~> Type | nil
parse_message  :: SMS         -> Maybe ParseResult
build_order    :: ParseResult -> Maybe Order
validate_order :: Order       -> Maybe Order
record         :: Order       -> Maybe Order
send_response  :: Order       -> Maybe String

sms_order_placer :: SMS -> Maybe String

Example - Maybe

-- Maybe Type ~> Type | nil
parse_message  :: SMS         -> Maybe ParseResult
build_order    :: ParseResult -> Maybe Order
validate_order :: Order       -> Maybe Order
record         :: Order       -> Maybe Order
send_response  :: Order       -> Maybe String

sms_order_placer :: SMS -> Maybe String

Example - Either

-- E[Type] = Either Type String
parse_message  :: SMS         -> E[ParseResult]
build_order    :: ParseResult -> E[Order]
validate_order :: Order       -> E[Order]
record         :: Order       -> E[Order]
send_response  :: Order       -> E[String]

sms_order_placer :: SMS -> E[String]

Example - Either

-- E[Type] = Either Type String
parse_message  :: SMS         -> E[ParseResult]
build_order    :: ParseResult -> E[Order]
validate_order :: Order       -> E[Order]
record         :: Order       -> E[Order]
send_response  :: Order       -> E[String]

sms_order_placer :: SMS -> E[String]

Either = Struct.new :value, :error

class SMS::OrderPlacer
  def success value; Either.new value, nil; end
  def error   err;   Either.new nil, err  ; end

  # N.B. This just uses regular old return values
  def validate order
    return error("Can't order none many supplies") if order.supplies.none?
    return error("Something else") if ...
    success order
  end
end

Example - Either

-- E[Type] = Either Type String
parse_message  :: SMS         -> E[ParseResult]
build_order    :: ParseResult -> E[Order]
validate_order :: Order       -> E[Order]
record         :: Order       -> E[Order]
send_response  :: Order       -> E[String]

sms_order_placer :: SMS -> E[String]

class SMS::OrderPlacer
  def compose *methods
    ->(val) do
      methods.reduce(val) do |result, m|
        if result.error
          result
        else
          func = m.respond_to?(:call) ? m : method(m)
          func.call result.value
        end
      end
    end
  end
end

Example - Logging

Example - Logging

-- LE[Type] = (Either Type String, [String])
parse_message  :: SMS         -> LE[ParseResult]
build_order    :: ParseResult -> LE[Order]
validate_order :: Order       -> LE[Order]
record         :: Order       -> LE[Order]
send_response  :: Order       -> LE[String]

sms_order_placer :: SMS -> LE[String]

Example - Logging

class SMS::OrderPlacer
  def success value, *messages
    [Either.new(value, nil), messages]
  end

  # record :: Order -> [Either Order String, [String]]
  def record order
    if db.save_order(order)
      success order, "Saved order with #{order.supplies.count} supplies"
    else
      error ...
    end
  end
end

Example - Logging

class SMS::OrderPlacer
  def compose *methods
    ->(val) do
      methods.reduce([val, []]) do |result, m|
        either, logs = result[0], result[1]
        if either.error
          result
        else
          func = m.respond_to?(:call) ? m : method(m)
          new_value, new_logs = func.call either.value

          [new_value, logs + new_logs]
        end
      end
    end
  end
end

Extending Composition

A

B

C

D

E

• an A or an error object
• a list of A's
• a promise returning an A
• a probability distribution of A's
• writing to a stream and returning an A
• reading from a repo and returning an A

Extending Composition

A

B

C

D

E

M[A]

M[B]

M[C]

M[D]

M[E]

• M is a functor
• "Moving up" is lift or map
• Exercise: convince yourself that List is a functor (and map is map)

Extending Composition

A

B

C

D

E

M[A]

M[B]

M[C]

M[D]

M[E]

• Vertical lines are return or pure
• Diagram is commutative

Extending Composition

A

B

C

D

E

M[A]

M[B]

M[C]

M[D]

M[E]

• M is a monad
• "Moving up" is bind or >>=
• Exercise: List is a monad (what is bind?)

Parting Thoughts

• Sorry for writing another monad tutorial
• If you're interested in trying this style out on e.g. your service layer check out pzol/deterministic and dry-rb/dry-container
• Blog post and references to follow

James Dabbs

@jamesdabbs

github/jamesdabbs