[Suggestion] pipe and compose operator for mutator function

[xareelee]

I just subscribe your episodes. It's great!

In Episode #2 and Episode #3, you introduce |> and <> to pipe and compose for mutator functions.

I have some thoughts about it. This is just suggestion and leaving for discussion.

1. Using |!> and >!> to instead of |> and <> for mutator functions

// from this
config |> inoutDecimalStyle <> inoutCurrencyStyle

// to this
config |!> inoutDecimalStyle >!> inoutCurrencyStyle

• |!> is mutator version of |>
• >!> is mutator version of >>>

The operators ending with !> (e.g. |!> and >!>) indicate that they are mutator operators which introduce mutations (or side effects). When you need to find those mutator operators in the project, this design would be much useful and helpful by searching with regex.

The ! in the operators indicates:

• It will handle a mutator function which return type is Void;
• it makes the mutator functions return their mutated input values, and
• it still is pipeable/chainable with following |>

2. Make |!> really pipeable/chainable with following |>

In the original implementation, the following code doesn't work:

let button = config 
  |!> inoutDecimalStyle >!> inoutCurrencyStyle
  |> buildButtonWithStyle      // |!> doesn't return any value

To make |!> pipeable/chainable just like fluent API:

// from this
func |!> <A>(a: inout A, f: (inout A) -> Void) -> Void {
  f(&a)
}

// to this
func |!> <A>(a: inout A, f: (inout A) -> Void) -> A {
  f(&a)
  return a  // return the mutated input value
}

Now you can chain up the |!> with |>

let button = config 
  |!> inoutDecimalStyle >!> inoutCurrencyStyle
  |> buildButtonWithStyle

Note: Yon can't chain up multiple |!> with value type mutators, because the return value of the first |!> is immutable which can't pipe into the inout mutator again. You need to compose those value type mutators first and pipe:

config |!> inoutDecimalStyle >!> inoutCurrencyStyle  // OK
config |!> inoutDecimalStyle |!> inoutCurrencyStyle  // Error: left side of mutating operator isn't mutable: '|!>' returns immutable value

3. Make |!> support ref type mutators

Overload the mutator operators to support ref types:

func |!> <A: AnyObject>(a: A, f: (A) -> Void) -> A {
  f(a)
  return a
}
func >!> <A: AnyObject>(
  f: @escaping (A) -> Void,
  g: @escaping (A) -> Void)
-> ((A) -> Void) {

  return { a in
    f(a)
    g(a)
  }
}

It makes you possibly chain the ref type mutator functions as following:

// from this
let emailField = UITextField()
emailTextFieldStyle(emailField)

let passwordField = UITextField()
passwordTextFieldStyle(passwordField)

// to this
let emailField = UITextField()
  |!> emailTextFieldStyle

let passwordField = UITextField()
  |!> passwordTextFieldStyle
  |!> otherRefTypeMutatorIfYouWant
  |> yesYouCanPipeWithPureFunctions

It's possible chaining up multiple |!> with ref type mutator functions, because the mutator functions don't use inout.

Conclusion

Using mutator operators indicates that it will pipe or compose mutator functions with Void return type into the point-free style, including:

• A value type mutator function which is (inout A) -> Void
• A ref type mutator function which is (A: AnyObject) -> Void

Using different symbols for mutator operators would be more readable and maintainable. Leave |> and <> for its original meaning (pure pipe and semigroup concat).

For best practice, you should name the mutator functions with prefix set (mutate the state of the data object):

// from this
let button = config 
  |!> inoutDecimalStyle >!> inoutCurrencyStyle

let emailField = UITextField()
  |!> emailTextFieldStyle

// to this
let button = config
  |!> setDecimalStyle >!> setCurrencyStyle   // value type setter/mutator

let emailField = UITextField()
  |!> setEmailTextFieldStyle   // ref type setter/mutator

[stephencelis]

Thanks for the discussion! Some fun ideas 😄 I'm going to move it over to the discussions tab.