úÎLéL    Safe-Inferred  /https://en.wikipedia.org/wiki/Identity_functionIdentity function.:Use this function to always return the value it was given. identity TrueTrueJThis is useful when constructing a function that returns another function.,let f x = if even x then recip else identityf 2 100.1f 3 1010.0This is like the   function from the Prelude. /https://en.wikipedia.org/wiki/Constant_functionConstant function.\Use this function to always return some value, regardless of what the other argument is.always True FalseTrue^This can be useful with higher-order functions. For example, this creates a list of three Trues.map (always True) [1 .. 3][True,True,True]This is like the   function from the Prelude. 2https://en.wikipedia.org/wiki/Function_compositionFunction composition.DUse this function to combine two other functions. The result of  f g+ will be a new function that first applies f and then applies g. In other words,  f g x is the same as g (f x)Z. For instance, the following example will first add one and then multiply by two.let f = compose (+ 1) (* 2)f 38”You can compose many functions together, but it quickly becomes unwieldy. This example does what the previous one did and then cubes the result.+let g = compose (compose (+ 1) (* 2)) (^ 3)g 3512&This is like the function form of the   operator from the Prelude.Left-associative  operator.UUse this operator to combine two other functions in a more natural way than with . The result of f  g/ will be a new function that first applies f and then applies gH. Here is the same example from above rewritten using this operator.let f = (+ 1) .> (* 2)f 38~When reading code, it is useful to pronounce this operator as "and then". So the above example could be read as: Add one, and then multiply by two".IWhen composing many functions, it's easier to use this operator than (. Compare this with the earlier example.let g = (+ 1) .> (* 2) .> (^ 3)g 3512"This is like a flipped version of   operator from the Prelude.Right-associative  operator.VSometimes it is more convenient to combine functions in the opposite direction as . The result of g  f) will be a new function that applies g but first applies f;. Here is the same example from before rewritten again.let f = (* 2) <. (+ 1)f 38ˆWhen reading code, it is useful to pronounce this operator as "but first". So the above example could be read as: "Multiply by two,  but first add one".@Using this operator also leads to more readable code than using  with many functions.let g = (^ 3) <. (* 2) <. (+ 1)g 3512This is like the   operator from the Prelude. 2https://en.wikipedia.org/wiki/Function_applicationFunction application.,This function isn't usually necessary since  x f is the same as f x.apply (apply 3 (+ 1)) (* 2)8FHowever it can come in handy when working with higher-order functions.map (apply 3) [(+ 1), (* 2)][4,6]This is like the  operator from the Prelude.Left-associative  operator.qSince this operator has such low precedence, it can be used to remove parentheses in complicated expressions.3 |> (+ 1) |> (* 2)8{When reading code, it is useful to pronounce this operator as "pipe into". So the above example can be read as: "Three  piped into plus one,  piped into times two".:It can also be used with higher-order functions, although  might be clearer.map (3 |>) [(+ 1), (* 2)][4,6]&This is like a flipped version of the  operator from the Prelude.Right-associative  operator.Like J, this operator also has low precedence. Use it to remove parentheses.(* 2) <| (+ 1) <| 38When reading code, it is useful to pronounce this operator as "pipe from". So the above example can be read as: "Times two  piped from plus one,  piped from 3".GWith higher-order functions, it can be a convenient alternative to flip .map (<| 3) [(+ 1), (* 2)][4,6]This is like the  operator from the Prelude.Strict function application.This is the strict version of %. It evaluates its argument with ? before applying it to the given function. In other words,  x f is the same as x `seq`  x f.apply' undefined (const 0) *** Exception: Prelude.undefinedThis is like the  operator from the Prelude. Left-associative  operator."This is the strict version of the  operator.undefined !> const 0 *** Exception: Prelude.undefined&This is like a flipped version of the  operator from the Prelude. Right-associative  operator."This is the strict version of the   operator.const 0 <! undefined *** Exception: Prelude.undefinedThis is like the  operator from the Prelude.                overture-0.0.1Overtureidentityalwayscompose.><.apply|><|apply'!>