98 Safe   Safe (x |> f) == f x(x |> f |> g) == g (f x)Left-associative  operator. Read as "apply forward" or "pipe into". Use this to create long chains of computation that suggest which direction things move in.3 |> succ |> recip |> negate-0.25"Or use it anywhere you would use ().(f <| x) == f x(g <| f <| x) == g (f x)Right-associative  operator. Read as "apply backward" or "pipe from". Use this to create long chains of computation that suggest which direction things move in. You may prefer this operator over ( ) for / actions since it puts the last function first.%print <| negate <| recip <| succ <| 3-0.25"Or use it anywhere you would use ().apply x f == f xFunction application. This function usually isn't necessary, but it can be more readable than some alternatives when used with higher-order functions like .#map (apply 2) [succ, recip, negate][3.0,0.5,-2.0](f .> g) x == g (f x)(f .> g .> h) x == h (g (f x))Left-associative  operator. Read as "compose forward" or "and then". Use this to create long chains of computation that suggest which direction things move in.let f = succ .> recip .> negatef 3-0.25"Or use it anywhere you would use ( ).(g <. f) x == g (f x)(h <. g <. f) x == h (g (f x))Right-associative  operator. Read as "compose backward" or "but first". Use this to create long chains of computation that suggest which direction things move in. You may prefer this operator over ( ) for / actions since it puts the last function first.(let f = print <. negate <. recip <. succf 3-0.25"Or use it anywhere you would use ( ).compose f g x == g (f x)Function composition. This function usually isn't necessary, but it can be more readable than some alternatives when used with higher-order functions like .+let fs = map (compose succ) [recip, negate]map (apply 3) fs [0.25,-4.0](x !> f) == seq x (f x)3(x !> f !> g) == let y = seq x (f x) in seq y (g y)Left-associative  operator. Read as "strict apply forward" or "strict pipe info". Use this to create long chains of computation that suggest which direction things move in.3 !> succ !> recip !> negate-0.25!The difference between this and (L) is that this evaluates its argument before passing it to the function.undefined |> const TrueTrueundefined !> const True *** Exception: Prelude.undefined...(f <! x) == seq x (f x)3(g <! f <! x) == let y = seq x (f x) in seq y (g y)Right-associative  operator. Read as "strict apply backward" or "strict pipe from". Use this to create long chains of computation that suggest which direction things move in. You may prefer this operator over () for / actions since it puts the last function first.%print <! negate <! recip <! succ <! 3-0.25!The difference between this and (L) is that this evaluates its argument before passing it to the function.const True <| undefinedTrueconst True <! undefined *** Exception: Prelude.undefined...apply' x f == seq x (f x)Strict function application. This function usually isn't necessary, but it can be more readable than some alternatives when used with higher-order functions like .$map (apply' 2) [succ, recip, negate][3.0,0.5,-2.0]The different between this and K is that this evaluates its argument before passing it to the function.apply undefined (const True)Trueapply' undefined (const True) *** Exception: Prelude.undefined...          !flow_4jETcHm0EJIFrf49mHV2WvFlow Paths_flowPrelude&IO$mapControl.Category>>>.|><|apply.><.compose!>