Compose two functions. `f .: g` is similar to `f . g`
except that `g` will be fed *two* arguments instead of one
before handing its result to `f`.
This function is defined as
*two* arguments (the function *and* the list)
will be given to `map` before the result is passed to
`concat`. This is equivalent to:

(f .: g) x y = f (g x y)Example usage:

concatMap :: (a -> [b]) -> [a] -> [b] concatMap = concat .: mapNotice how

concatMap f xs = concat (map f xs)

Equivalent to .:
The pattern of appending asterisks is straightforward to extend to
similar functions: (compose2 = .*, compose3 = .**, etc). However,
`.:` has been commonly adopted amongst Haskellers, and the need
for compose3 and beyond is rare in practice.

Compose composed with compose operator.

(f ... g) x y === f (g x y)

Compose functions with one argument with function with two arguments.
`f .: g = \x y -> f (g x y)`.

Binary composition: pass two args to the right argument before
composing.
`(f .) . g` but more
easily extended to multiple uses, due to the fixity declaration.

(f .: g) x y = f (g x y)or,

f .: g = curry (f . uncurry g)This is the same as the common idiom

Wrap the result of a function applied to 2 arguments.