Let's define a new custom operator to use instead of our composed function:

precedencegroup AssociativityLeft { 
    associativity: left 
} 

infix operator |> : AssociativityLeft 
func |> <T, V>(f: @escaping (T) -> V, g: @escaping (V) -> V ) -> (T) -> V { 
    return { x in g(f(x)) } 
} 

let composedWithCustomOperator = extractElements |> formatWithCurrency 
composedWithCustomOperator("10,20,40,30,80,60") 
// The result will be: ["10$", "20$", "40$", "30$", "80$", "60$"] 

In this example, we have defined a new operator, |>, that takes two generic functions and combines them, returning a function that has the first function's input as the parameter and the second function's return as the return type.

As this new operator is going to combine two functions and is binary, we defined it as infix. Then we need to use the operator keyword. The next step will be to choose the notation for our new custom operator. As we will group functions to the left, we need to specify it as associativity left.

To be able to use this operator, we need to define a corresponding function. Our function takes two functions as follows:

• f: This function takes a generic type of T and returns a generic type of V
• g: This function takes a generic type of V and returns a generic type of V

In our previous example, we had the following functions:

• extractElements - String -> [String]
• formatWithCurrency - [String] -> [String]

So T becomes String and V becomes [String].

Our |> function returns a function that takes a generic type of T and returns a generic type of V. We need to receive the String -> [String] from the composed function so, again, T becomes String and V becomes [String].

Using our|> custom operator makes our code more readable and less verbose. Do not worry about @escaping for now, we will talk about it in the Closures--Capturing values section of this chapter.