Railway-Oriented Programming in PHP

A presentation by @stuherbert  for @GanbaroDigital Railway-Oriented Programming A Functional
Approach In PHP

Industry veteran: architect, engineer, leader, manager, mentor F/OSS contributor since
1994 Talking and writing about PHP since 2004 Chief Software Archaeologist Building Quality @GanbaroDigital About Stuart

Follow me I do tweet a lot about non-tech stuff
though :) @stuherbert

@GanbaroDigital I am not a functional programmer.

@GanbaroDigital https://ﬂic.kr/p/bWVcA1 I’m On A Quest

@GanbaroDigital My interest is making code more reusable.

@GanbaroDigital My second interest is making code easier to reason
about.

@GanbaroDigital My third interest is making code more robust.

@GanbaroDigital RRR Development • Reusable • Reason about it •
Robust ... without sacriﬁcing performance!

@GanbaroDigital https://ﬂic.kr/p/iH2v8F Am I Tilting At Windmills?

@GanbaroDigital Why Look At Functional Programming?

@GanbaroDigital “ PHP is an imperative language ... ... with
a Java-ish OOP identity.

@GanbaroDigital “ Reuse in OO is, always has been, and
always will be disappointing.

@GanbaroDigital Reuse Challenges • Side effects • High coupling •
Bitrot / fragility to change

@GanbaroDigital Classes and objects normally* wrap state in behaviour

@GanbaroDigital Object

@GanbaroDigital Object Data

@GanbaroDigital Object Data Methods

@GanbaroDigital That’s not the whole picture.

@GanbaroDigital Object

@GanbaroDigital What We Can See What We Can’t See

@GanbaroDigital “ When there’s high-coupling, there’s high sensitivity to change.

@GanbaroDigital “A change in one of the things we can’t
see can break the one thing we can see.

@GanbaroDigital ?? ?? Do we notice the breakage a) at
all? b) before we ship?

@GanbaroDigital ?? ?? How long does it take to ﬁnd
the cause of the breakage?

@GanbaroDigital “ It’s the nature of OOP to create highly-coupled
code.

@GanbaroDigital “ Breaking large objects / methods into smaller ones
does nothing to reduce coupling.

@GanbaroDigital That’s why I’m interested in other programming paradigms to
help me on my quest.

@GanbaroDigital Your quest will be different, and just as valid.
I’m here to learn from you too!

@GanbaroDigital Railway-Oriented Programming

@GanbaroDigital Scott Wlaschin  https://fsharpforfunandproﬁt.com/

@GanbaroDigital https://vimeo.com/113707214

@GanbaroDigital What Is Railway-Oriented Programming?

@GanbaroDigital

@GanbaroDigital input

@GanbaroDigital input output

@GanbaroDigital “The Tunnel of Transformation” input output

@GanbaroDigital strtoupper()

@GanbaroDigital strtoupper() string

@GanbaroDigital strtoupper() string string

@GanbaroDigital strtoupper() apple

@GanbaroDigital strtoupper() apple APPLE

@GanbaroDigital “ One thing goes in, a new thing comes
out. The thing that went in remains unchanged.

@GanbaroDigital

@GanbaroDigital { Composability

@GanbaroDigital Scott’s interest in ROP started from error handling.

@GanbaroDigital ?? ?? What happens when things go wrong?

@GanbaroDigital validateEmail() string string

@GanbaroDigital validateEmail() string string error

@GanbaroDigital We could throw an Exception instead.

@GanbaroDigital https://ﬂic.kr/p/fArumY Pyramid of Dooom!

@GanbaroDigital public function validateEmail($email) { if (preg_match(..., $email)) { if
(not_blacklisted($email)) { if (mailbox_exists($email)) { return $email; } } } throw new Exception(...); }

@GanbaroDigital All Joking Aside ... • Nested ‘if’ adds testing
complexity • Becomes fragile over time, as rules change

@GanbaroDigital Can we replace the Pyramid of Doom with ROP?

@GanbaroDigital public function validateEmail($email) { if (preg_match(..., $email)) { if
(not_blacklisted($email)) { if (mailbox_exists($email)) { return $email; } } } throw new Exception(...); }

@GanbaroDigital emailFormat() notBlacklisted() mailboxExists()

@GanbaroDigital These 1 in, 2 out functions aren’t composable.

@GanbaroDigital emailFormat() string string error

@GanbaroDigital ?? ?? How would you ﬁx that?

@GanbaroDigital emailFormat() string string error error

@GanbaroDigital We start off without an error. Conceptually, the error
parameter is optional.

@GanbaroDigital validateEmail() is built from functions composed together.

@GanbaroDigital validateEmail() string string

@GanbaroDigital ?? ?? Who decides to stop calling the function
chain?

@GanbaroDigital I hate submitting a web form, and getting back
1 error at a time

@GanbaroDigital “ Because there are no side-effects we can safely
run the whole pipeline where that makes sense.

@GanbaroDigital ROP Input Parameters • Primary data parameter • Optional
existing error(s) parameter

@GanbaroDigital ROP Function Actions • Apply logic to input data
• Produce new output data • Input data remains unchanged

@GanbaroDigital ROP Function Outputs • The (possibly transformed) data •
(Aggregated) error reporting

@GanbaroDigital ROP Function Composition • Maybe we want to short-circuit
on error • Maybe we want to aggregate errors • This is policy - it belongs in the calling code

@GanbaroDigital ?? ?? What would ROP look like in PHP?

@GanbaroDigital PHP is an imperative language. It lacks things that
functional programmers take for granted.

@GanbaroDigital FL Advantages • Type system • Compile-time checks* •
Monads & monoids

@GanbaroDigital ?? ?? Should we simply emulate monads in PHP?

@GanbaroDigital We can emulate the ﬂow logic of Monads. We
can’t emulate the type system that makes them practical.

@GanbaroDigital Let’s revisit this question after the code demos.

@GanbaroDigital ROP in PHP

@GanbaroDigital Starting Requirements • Data input, optional error input •
Data output, error output • Input data treated as immutable

@GanbaroDigital Design Constraints • Functions must be composable • Short-circuit
logic sits outside composed functions

@GanbaroDigital https://ﬂic.kr/p/cwK7UN

@GanbaroDigital Measured Outcomes • Reasonability • Reusability • Robustness

@GanbaroDigital Example 1: Simple ROP Functions

@GanbaroDigital

@GanbaroDigital This is the simplest solution I’ve been able to
ﬁnd to date.

@GanbaroDigital The Simple Approach • Arg 1 - always the
data to transform • Arg 2 - optional failure data • Returns 2-element array

@GanbaroDigital Why Return An Array? • Arrays outperform objects in
PHP • No need to deﬁne any classes, or pull in any third-party packages

@GanbaroDigital The output of one ROP function becomes the input
of the next one.

@GanbaroDigital

@GanbaroDigital Use the ‘...’ token to compose the ROP functions.

@GanbaroDigital

@GanbaroDigital The ‘...’ token allows us to nest calls ...

@GanbaroDigital

@GanbaroDigital ... but readability suffers* as the nesting deepens  
* ends up looking functional

@GanbaroDigital

@GanbaroDigital “ Most people ﬁnd linear code easier to read.

@GanbaroDigital

@GanbaroDigital Reasonability: Reusability: Robustness: ✓

@GanbaroDigital “ Standardisation encourages interoperability and reusability.

@GanbaroDigital “ A standardised approach allows us to reuse logic
to create new logic.

@GanbaroDigital

@GanbaroDigital Reasonability: Reusability: Robustness: ✓ ½

@GanbaroDigital Some Observations • Failure is currently a placeholder •
Return values aren’t typed

@GanbaroDigital We’ll come back to handling failure shortly.

@GanbaroDigital Some Observations • Failure is currently a placeholder •
Return values aren’t typed

@GanbaroDigital ?? ?? How do we feel about the return
types?

@GanbaroDigital

@GanbaroDigital Example 2: Business Domain

@GanbaroDigital Let’s model a very simple* e-commerce order.

@GanbaroDigital

@GanbaroDigital “ The business model is logic that is applied
to the data model.

@GanbaroDigital “Separate the business model from the data model for
ﬂexibility and long-term stability.

@GanbaroDigital

@GanbaroDigital Both of our example functions return new Orders. The
original Order is left unchanged.

@GanbaroDigital If anything goes wrong*, we still have the original
Order. * and it will :-)

@GanbaroDigital ?? ?? How do we make these functions composable?

@GanbaroDigital

@GanbaroDigital Having standalone functions that you then wrap can be
easier to unit test.

@GanbaroDigital

@GanbaroDigital Use a function that returns a function to make
things composable AND avoid hard-coding parameters.

@GanbaroDigital

@GanbaroDigital ?? ?? How do you feel about lambda functions
in PHP?

@GanbaroDigital Rule of thumb: any function that takes 1 parameter
and isn’t built from composed functions assume it has something hard-coded in there until you prove otherwise!

@GanbaroDigital

@GanbaroDigital With the ROP approach, you might end up building
a lot of lambda functions.

@GanbaroDigital These builders are creating partial functions.

@GanbaroDigital We can create a reusable partial function builder.

@GanbaroDigital

@GanbaroDigital Partial Function Builder • Reduces amount of code to
write • Requires main data to be ﬁrst parameter of the wrapped function • Convenience over runtime performance • No type-safety

@GanbaroDigital “ A standardised business domain can adapt to change.

@GanbaroDigital Let’s add discount codes to our worked example.

@GanbaroDigital Requirements • Applied after all other costs • Show
the discount to make the customer feel the value

@GanbaroDigital

@GanbaroDigital Requirements • Applied after all other costs • Show
the discount to make the customer feel the value

@GanbaroDigital

@GanbaroDigital A purely imperative approach is readable but has a
larger change surface.

@GanbaroDigital

@GanbaroDigital A composable / ROP approach has a smaller change
surface but requires more mental space.

@GanbaroDigital

@GanbaroDigital Introducing discounts hasn’t touched our gross calculation at all!

@GanbaroDigital The composable / ROP approach is very suited to
switching business logic at runtime.

@GanbaroDigital It’s one way to adopt the DDD “speciﬁcations” concept.

@GanbaroDigital Reasonability: Reusability: Robustness: ✓ ¾

@GanbaroDigital Scott talked about ROP as an approach to error
handling. We can’t put it off any longer :-)

@GanbaroDigital Example 3: Failure

@GanbaroDigital

@GanbaroDigital ?? ?? How can we handle the missing VAT
code?

@GanbaroDigital

@GanbaroDigital get_vat_rate() silently hides an error from elsewhere

@GanbaroDigital get_vat_rate() is propagating an error that we cannot see

@GanbaroDigital ?? ?? How can we handle the missing VAT
code?

@GanbaroDigital Option 1: throw an exception

@GanbaroDigital

@GanbaroDigital InvalidArgumentException is one of those things I wish we
could uninvent.

@GanbaroDigital Option 1 Consequences • We don’t need $failure at
all (not ROP!) • Generic exceptions are a huge time sink when investigating faults • Speciﬁc exceptions lead to large try/catch blocks* • try/catch blocks are part of our change surface area - Pryamid of Doom / fragile

@GanbaroDigital Option 2: return the error as $failure

@GanbaroDigital rop_get_vat_rate() string ﬂoat error error

@GanbaroDigital

@GanbaroDigital Option 2 Consequences • Everything has to agree on
what $failure is, and how to use it • Still need to return *something* as main data out • Someone needs to remember to check $failure

@GanbaroDigital Option 1 is effort and fragile. (And it’s the
current way) Option 2 requires 100% accuracy from humans.

@GanbaroDigital ?? ?? What if the caller tells us how
to handle failure?

@GanbaroDigital

@GanbaroDigital rop_get_vat_rate() string ﬂoat error error

@GanbaroDigital rop_get_vat_rate() string ﬂoat error handler error handler

@GanbaroDigital input output error handler error handler “The Tunnel of
Transformation”

@GanbaroDigital Option 3 Consequences • Everything still has to agree
on what $failure is, and how to use it • 2nd parameter is non-optional callback • Caller decides how to handle errors • Caller can throw exceptions if preferred

@GanbaroDigital Our partial function builder now knows what to expect
for the second parameter.

@GanbaroDigital

@GanbaroDigital Reasonability: Reusability: Robustness: ✓ ¾ ✓

@GanbaroDigital ?? ?? What about our reusability score?

@GanbaroDigital The error handler is provided at the point of
use not at the point of deﬁnition.

@GanbaroDigital

@GanbaroDigital Reasonability: Reusability: Robustness: ✓ ✓ ✓

@GanbaroDigital

Thank You Any Questions? A presentation by @stuherbert  for @GanbaroDigital

Railway-Oriented Programming in PHP

Railway-Oriented Programming in PHP

More Decks by Stuart Herbert

Other Decks in Programming

Featured

Transcript