scala

# Function

#### object Function extends AnyRef

A module defining utility methods for higher-order functional programming.

1. AnyRef
2. Any

### Value Members

1. #### def chain[a](fs: Seq[(a) ⇒ a]): (a) ⇒ a

Given a sequence of functions `f1`,

Given a sequence of functions `f1`, ..., `fn`, return the function ```f1 andThen ... andThen fn```.

fs

The given sequence of functions

returns

...

2. #### def const[T, U](x: T)(y: U): T

The constant function

The constant function

3. #### def curried[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) ⇒ b): (a1) ⇒ (a2) ⇒ (a3) ⇒ (a4) ⇒ (a5) ⇒ b

Currying for functions of arity 5

Currying for functions of arity 5.

4. #### def curried[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) ⇒ b): (a1) ⇒ (a2) ⇒ (a3) ⇒ (a4) ⇒ b

Currying for functions of arity 4

Currying for functions of arity 4.

5. #### def curried[a1, a2, a3, b](f: (a1, a2, a3) ⇒ b): (a1) ⇒ (a2) ⇒ (a3) ⇒ b

Currying for functions of arity 3

Currying for functions of arity 3.

f

...

returns

...

6. #### def curried[a1, a2, b](f: (a1, a2) ⇒ b): (a1) ⇒ (a2) ⇒ b

Currying for functions of arity 2

Currying for functions of arity 2. This transforms a function of arity 2 into a a unary function returning another unary function.

f

...

returns

...

7. #### def equals(arg0: Any): Boolean

This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence

This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

The default implementations of this method is an equivalence relation:

• It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`.
• It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`.
• It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override `hashCode` to ensure that objects that are "equal" (`o1.equals(o2)` returns `true`) hash to the same `Int` (`o1.hashCode.equals(o2.hashCode)`).

arg0

the object to compare against this object for equality.

returns

`true` if the receiver object is equivalent to the argument; `false` otherwise.

definition classes: AnyRef ⇐ Any
8. #### def hashCode(): Int

Returns a hash code value for the object

Returns a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`. However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the `equals` method.

definition classes: AnyRef ⇐ Any
9. #### def toString(): String

Returns a string representation of the object

Returns a string representation of the object.

The default representation is platform dependent.

definition classes: AnyRef ⇐ Any
10. #### def tupled[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) ⇒ b): ((a1, a2, a3, a4, a5)) ⇒ b

Tupling for functions of arity 5

Tupling for functions of arity 5. This transforms a function of arity 5 into a unary function that takes a 5-tuple of arguments.

11. #### def tupled[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) ⇒ b): ((a1, a2, a3, a4)) ⇒ b

Tupling for functions of arity 4

Tupling for functions of arity 4. This transforms a function of arity 4 into a unary function that takes a 4-tuple of arguments.

12. #### def tupled[a1, a2, a3, b](f: (a1, a2, a3) ⇒ b): ((a1, a2, a3)) ⇒ b

Tupling for functions of arity 3

Tupling for functions of arity 3. This transforms a function of arity 3 into a unary function that takes a triple of arguments.

13. #### def tupled[a1, a2, b](f: (a1, a2) ⇒ b): ((a1, a2)) ⇒ b

Tupling for functions of arity 2

Tupling for functions of arity 2. This transforms a function of arity 2 into a unary function that takes a pair of arguments.

f

...

returns

...

14. #### def uncurried[a1, a2, a3, a4, a5, b](f: (a1) ⇒ (a2) ⇒ (a3) ⇒ (a4) ⇒ (a5) ⇒ b): (a1, a2, a3, a4, a5) ⇒ b

Uncurrying for functions of arity 5

Uncurrying for functions of arity 5.

15. #### def uncurried[a1, a2, a3, a4, b](f: (a1) ⇒ (a2) ⇒ (a3) ⇒ (a4) ⇒ b): (a1, a2, a3, a4) ⇒ b

Uncurrying for functions of arity 4

Uncurrying for functions of arity 4.

16. #### def uncurried[a1, a2, a3, b](f: (a1) ⇒ (a2) ⇒ (a3) ⇒ b): (a1, a2, a3) ⇒ b

Uncurrying for functions of arity 3

Uncurrying for functions of arity 3.

17. #### def uncurried[a1, a2, b](f: (a1) ⇒ (a2) ⇒ b): (a1, a2) ⇒ b

Uncurrying for functions of arity 2

Uncurrying for functions of arity 2. This transforms a unary function returning another unary function into a function of arity 2.

18. #### def untupled[a1, a2, a3, a4, a5, b](f: ((a1, a2, a3, a4, a5)) ⇒ b): (a1, a2, a3, a4, a5) ⇒ b

Un-tupling for functions of arity 5

Un-tupling for functions of arity 5. This transforms a function taking a 5-tuple of arguments into a function of arity 5 which takes each argument separately.

19. #### def untupled[a1, a2, a3, a4, b](f: ((a1, a2, a3, a4)) ⇒ b): (a1, a2, a3, a4) ⇒ b

Un-tupling for functions of arity 4

Un-tupling for functions of arity 4. This transforms a function taking a 4-tuple of arguments into a function of arity 4 which takes each argument separately.

20. #### def untupled[a1, a2, a3, b](f: ((a1, a2, a3)) ⇒ b): (a1, a2, a3) ⇒ b

Un-tupling for functions of arity 3

Un-tupling for functions of arity 3. This transforms a function taking a triple of arguments into a ternary function which takes each argument separately.

21. #### def untupled[a1, a2, b](f: ((a1, a2)) ⇒ b): (a1, a2) ⇒ b

Un-tupling for functions of arity 2

Un-tupling for functions of arity 2. This transforms a function taking a pair of arguments into a binary function which takes each argument separately.