úÎ.-•  Safe-Inferred apply x f == f x 2https://en.wikipedia.org/wiki/Function_applicationFunction application. This is like the  operator.apply False notTrue;Using this function with many arguments is cumbersome. Use  or  instead."False `apply` not `apply` fromEnum1,This function usually isn't necessary since  x f is the same as f xL. However it can come in handy when working with higher-order functions.map (apply False) [not, id] [True,False](x |> f) == f x(x |> f |> g) == g (f x)Left-associative 5 operator. This is like a flipped version of the 5 operator. Read it as "apply forward" or "pipe into". False |> notTruesSince this operator has such low precedence, it can be used to remove parentheses from complicated expressions.False |> not |> fromEnum1;This operator can be used with higher-order functions, but  might be clearer.map (False |>) [not, id] [True,False](f <| x) == f x(g <| f <| x) == g (f x)Right-associative  operator. This is like the : operator. Read it as "apply backward" or "pipe from". not <| FalseTrueoThis operator can be used to remove parentheses from complicated expressions because of its low precedence.fromEnum <| not <| False1KWith higher-order functions, this operator is a clearer alternative to flip .map (<| False) [not, id] [True,False]compose f g x == g (f x) 2https://en.wikipedia.org/wiki/Function_compositionFunction composition. This is like the  operator.(compose not fromEnum) False1@Composing many functions together quickly becomes unwieldy. Use  or  instead.-(not `compose` fromEnum `compose` succ) False2(f .> g) x == g (f x)(f .> g .> h) x == h (g (f x))Left-associative 5 operator. This is like a flipped version of the 6 operator. Read it as "compose forward" or "and then".(not .> fromEnum) False1IThanks to its high precedence, composing many functions together is easy.(not .> fromEnum .> succ) False2(g <. f) x == g (f x)(h <. g <. f) x == h (g (f x))Right-associative  operator. This is like the < operator. Read it as "compose backward" or "but first".(fromEnum <. not) False1HComposing many functions together is easy thanks to its high precedence.(succ <. fromEnum <. not) False2apply' x f == seq x (f x).Strict function application. This is like the  operator.apply' undefined (const False) *** Exception: Prelude.undefined(x !> f) == seq x (f x)((x !> f !> g) == seq x (g (seq x (f x)))Left-associative 5 operator. This is like a flipped version of the  operator.undefined !> const False *** Exception: Prelude.undefined(f <! x) == seq x (f x)((g <! f <! x) == seq x (g (seq x (f x)))Right-associative  operator. This is like the  operator.const False <! undefined *** Exception: Prelude.undefined             flow-1.0.1FlowPrelude$.$!apply|><|compose.><.apply'!>