concept expression in category system administration

This is an excerpt from Manning's book Functional and Reactive Domain Modeling. Login to get full access to this book.

Consider the definitions from listing 1.6, which implements debit and credit as pure functions. Using the model, you can write assertions that validate your implementation. These are called properties of the model, and the following code snippet provides the verification of correctness of the model. You start with an expression that performs a credit and a debit of equal amounts in succession to an account. This should give you the original balance of the account before you executed this expression. To validate this property, you substitute our implementation in each step of the derivation (just as you do when you solve a mathematical equation) and finally arrive at your result.

Figure 2.2. Difference between statements and expressions. This summary explains clearly why you should choose expressions over statements when you’re thinking of functional composition.

10.2.1. Think in expressions

An expression is something that has a value. On the other hand, statements yield a side effect. The value that an expression generates can be passed around in functions, generating bigger expressions. Evolve your domain behaviors as expressions generated bottom up from smaller ones so that you can compose them better with other behaviors. Let’s recap an example from section 4.2.3 on monadic effects:

object App extends AccountService {
  def op(no: String) = for {
    _ <- credit(no, BigDecimal(100))
    _ <- credit(no, BigDecimal(300))

    _ <- debit(no, BigDecimal(160))
    b <- balance(no)
  } yield b
}

copy

The function op generates a value by evaluating the for-expression. Each clause within the for-comprehension is again an expression that generates separate values that get chained together through a sequence of flatMaps and maps to yield the final value. Thinking in expressions helps you think in terms of composition, making evolution of domain behaviors more natural and incremental. Instead of committing to the side effect early on, use combinators to abstract the effect so that you can compose into more complex behaviors without breaking the chain of expressions.^[1]