Rewrite Currying tour as Multiple Parameter Lists

_tour/case-classes.md

@@ -8,7 +8,7 @@ partof: scala-tour
 
 num: 11
 next-page: pattern-matching
-previous-page: currying
+previous-page: multiple-parameter-lists
 prerequisite-knowledge: classes, basics, mutability
 
 redirect_from: "/tutorials/tour/case-classes.html"

_tour/multiple-parameter-lists.md

@@ -0,0 +1,44 @@
+---
+layout: tour
+title: Multiple Parameter Lists
+
+discourse: true
+
+partof: scala-tour
+
+num: 10
+next-page: case-classes
+previous-page: nested-functions
+
+redirect_from: "/tutorials/tour/multiple-parameter-lists.html"
+---
+
+Methods may define multiple parameter lists. When a method is called with a fewer number of parameter lists, then this will yield a function taking the missing parameter lists as its arguments.
+
+Here is an example, defined in [Traversable](/overviews/collections/trait-traversable.html) trait from Scala collections:
+
+```
+def foldLeft[B](z: B)(op: (B, A) => B): B
+```
+
+`foldLeft` applies a binary operator `op` to an initial value `z` and all elements of this traversable, going left to right. Here is an example of its usage:
+
+```tut
+val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+val res = numbers.foldLeft(0)((m: Int, n: Int) => m + n)
+print(res) // 55
+```
+
+Starting with an initial value of 0, `foldLeft` applies the function `(m: Int, n: Int) => m + n` to each element in the List and the previous accumulated value.
+
+Multiple parameter lists have a more verbose invocation syntax; and hence should be used sparingly. Suggested use cases include:
+
+1. ##### Implicit parameters
+    To specify certain parameters in a parameter list as `implicit`, multiple parameter lists should be used. An example of this is:
+
+    ```
+    def execute(arg: Int)(implicit ec: ExecutionContext) = ???
+    ```
+
+2. ##### Single functional parameter
+    In case of a single functional parameter, like `op` in the case of `foldLeft` above, multiple parameter lists allow a concise syntax to pass an anonymous function to the method.

_tour/nested-functions.md

@@ -7,7 +7,7 @@ discourse: true
 partof: scala-tour
 
 num: 9
-next-page: currying
+next-page: multiple-parameter-lists
 previous-page: higher-order-functions
 
 redirect_from: "/tutorials/tour/nested-functions.html"

_tour/tour-of-scala.md

@@ -19,7 +19,7 @@ Scala is a modern multi-paradigm programming language designed to express common
 Scala is a pure object-oriented language in the sense that [every value is an object](unified-types.html). Types and behavior of objects are described by [classes](classes.html) and [traits](traits.html). Classes are extended by subclassing and a flexible [mixin-based composition](mixin-class-composition.html) mechanism as a clean replacement for multiple inheritance.
 
 ## Scala is functional ##
-Scala is also a functional language in the sense that [every function is a value](unified-types.html). Scala provides a [lightweight syntax](basics.html#functions) for defining anonymous functions, it supports [higher-order functions](higher-order-functions.html), it allows functions to be [nested](nested-functions.html), and supports [currying](currying.html). Scala's [case classes](case-classes.html) and its built-in support for [pattern matching](pattern-matching.html) model algebraic types used in many functional programming languages. [Singleton objects](singleton-objects.html) provide a convenient way to group functions that aren't members of a class.
+Scala is also a functional language in the sense that [every function is a value](unified-types.html). Scala provides a [lightweight syntax](basics.html#functions) for defining anonymous functions, it supports [higher-order functions](higher-order-functions.html), it allows functions to be [nested](nested-functions.html), and supports [currying](multiple-parameter-lists.html). Scala's [case classes](case-classes.html) and its built-in support for [pattern matching](pattern-matching.html) model algebraic types used in many functional programming languages. [Singleton objects](singleton-objects.html) provide a convenient way to group functions that aren't members of a class.
 
 Furthermore, Scala's notion of pattern matching naturally extends to the [processing of XML data](https://github.com/scala/scala-xml/wiki/XML-Processing) with the help of [right-ignoring sequence patterns](regular-expression-patterns.html), by way of general extension via [extractor objects](extractor-objects.html). In this context, [for comprehensions](for-comprehensions.html) are useful for formulating queries. These features make Scala ideal for developing applications like web services.