How to avoid unnecessary computation when composing pure functions in a functional language?

Question

I have two functions that are a composition of pure functions. The first function takes a parcel, builds a house on it, and take a picture to advertise it in a magazine:

let buildAndAdvertiseHouse parcel = 
    parcel
    |> inspect
    |> buildWalls
    |> buildRoof
    |> takePhoto
    |> advertise

The second function takes also a parcel, builds a house on it, and adds a finishing touch to it:

let buildAndCompleteHouse parcel = 
    parcel
    |> inspect
    |> buildWalls
    |> buildRoof
    |> paintWalls
    |> addFurniture

It's clear that the two functions are also pure, since they are a composition of pure functions. Now I have a parcel, let say niceParcel and I want to apply both functions to it. However, I want to avoid that the first three sub-functions are calculated twice since they take a big time to compute and they are shared among the two functions.

How do I refactor my code, so these unnecessary calculations are avoided, while keeping these nice pure functions which have a clear meaning?

If `parcel` is not a generic type, then you can make the code more idiomatic with `let buildAnd... = inspect >> buildWalls >> ... >> advertise` (and with proper indentation) — Ramon Snir, Aug 29 '13 at 08:09
Regarding the question, why not split your two functions into three functions named `build`, `advertise` and `completeHouse`? — Ramon Snir, Aug 29 '13 at 08:10
They form one entity that can be used in different parts of the program. Of course they can be split, but then this entity is lost. In that case, if you want to use them, you would have to know the inner workings, namely that it is first built and then completed or advertised. I want to avoid that you have to know the inner workings. — Tuur, Aug 29 '13 at 09:51
If you don't want to decompose the functions into individual parts, which is evident from your comments, then you should probably use some memoization technique on the functions that are computationally intensive. — Ankur, Aug 29 '13 at 10:57

score 5 · Answer 1 · answered Aug 29 '13 at 14:17

As others mentioned in the comments, I think the best approach is to turn the common part into a build function. Even if you do not intend to use the function for other purposes, this is a clean way of structuring functional code.

In F#, you can define a type that represents a partially built house, but does not expose its internals. This means that the callers of your library can use build to build a partially constructed house, but then the only thing they can do with it is to use the two functions you provided:

module Houses = 
  type House = private HouseData of <whatever>
  let build parcel = (...)

  let buildAndAdvertiseHouse house = 
    house
    |> takePhoto
    |> advertise

  let buildAndCompleteHouse house = 
    house
    |> paintWalls
    |> addFurniture

You can hide the fact that one needs to build a house before you can advertise & complete it in various ways. For example, if you typically do both operations at once, then you can define a function that calls all three functions - and the user of your library can either just use this or learn a bit more about house building and use the three functions if they need a finer control.

Another approach would be to just wrap the functionality in a simple type. F# mixed functional and object-oriented style, so there is nothing really wrong with having a type that runs the common part once and keeps some state.

type House(parcel) = 
  let house = 
    parcel
    |> inspect
    |> buildWalls
    |> buildRoof

  member x.BuildAndAdvertiseHouse()
    house
    |> takePhoto
    |> advertise

  member x.BuildAndCompleteHouse() = 
    house
    |> paintWalls
    |> addFurniture

This is fine in F#, but I think I would prefer the functional approach with a build function.

How to avoid unnecessary computation when composing pure functions in a functional language?

1 Answers1