7 files changed, 48 insertions, 12 deletions
diff --git a/doc/tut2.txt b/doc/tut2.txt
index 4a4ef1757..c080d1339 100755
--- a/doc/tut2.txt
+++ b/doc/tut2.txt
@@ -218,7 +218,7 @@ So "pure object oriented" code is easy to write:
   import strutils
   
   stdout.writeln("Give a list of numbers (separated by spaces): ")
-  stdout.write(stdin.readLine.split.each(parseInt).max.`$`)
+  stdout.write(stdin.readLine.split.map(parseInt).max.`$`)
   stdout.writeln(" is the maximum!")
 
 
diff --git a/examples/maximum.nim b/examples/maximum.nim
index 1e26ee1a7..ac6160f76 100755
--- a/examples/maximum.nim
+++ b/examples/maximum.nim
@@ -3,4 +3,4 @@
 import strutils
 
 echo "Give a list of numbers (separated by spaces): "
-stdin.readLine.split.each(parseInt).max.`$`.echo(" is the maximum!")
+stdin.readLine.split.map(parseInt).max.`$`.echo(" is the maximum!")
diff --git a/lib/pure/collections/sequtils.nim b/lib/pure/collections/sequtils.nim
index 73713eec9..298e7f27e 100644
--- a/lib/pure/collections/sequtils.nim
+++ b/lib/pure/collections/sequtils.nim
@@ -12,8 +12,8 @@
 ## This module implements operations for the built-in `seq`:idx: type which
 ## were inspired by functional programming languages. If you are looking for
 ## the typical `map` function which applies a function to every element in a
-## sequence, it already exists as the `each` proc in the `system
-## <system.html>`_ module in both mutable and immutable styles.
+## sequence, it already exists in the `system <system.html>`_ module in both
+## mutable and immutable styles.
 ##
 ## Also, for functional style programming you may want to pass `anonymous procs
 ## <manual.html#anonymous-procs>`_ to procs like ``filter`` to reduce typing.
diff --git a/lib/system.nim b/lib/system.nim
index 130b8532f..85d952376 100755
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -1461,15 +1461,51 @@ proc pop*[T](s: var seq[T]): T {.inline, noSideEffect.} =
   result = s[L]
   setLen(s, L)
 
-proc each*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] = 
-  ## The well-known `map`:idx: operation from functional programming. Applies
+proc each*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] {.
+  deprecated.} =
+  ## The well-known ``map`` operation from functional programming. Applies
   ## `op` to every item in `data` and returns the result as a sequence.
+  ##
+  ## **Deprecated since version 0.9:** Use the ``map`` proc instead.
   newSeq(result, data.len)
   for i in 0..data.len-1: result[i] = op(data[i])
 
-proc each*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) =
-  ## The well-known `map`:idx: operation from functional programming. Applies
+proc each*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) {.
+  deprecated.} =
+  ## The well-known ``map`` operation from functional programming. Applies
   ## `op` to every item in `data` modifying it directly.
+  ##
+  ## **Deprecated since version 0.9:** Use the ``map`` proc instead.
+  for i in 0..data.len-1: op(data[i])
+
+proc map*[T, S](data: openArray[T], op: proc (x: T): S {.closure.}): seq[S] =
+  ## Returns a new sequence with the results of `op` applied to every item in
+  ## `data`.
+  ##
+  ## Since the input is not modified you can use this version of ``map`` to
+  ## transform the type of the elements in the input sequence. Example:
+  ##
+  ## .. code-block:: nimrod
+  ##   let
+  ##     a = @[1, 2, 3, 4]
+  ##     b = map(a, proc(x: int): string = $x)
+  ##   assert b == @["1", "2", "3", "4"]
+  newSeq(result, data.len)
+  for i in 0..data.len-1: result[i] = op(data[i])
+
+proc map*[T](data: var openArray[T], op: proc (x: var T) {.closure.}) =
+  ## Applies `op` to every item in `data` modifying it directly.
+  ##
+  ## Note that this version of ``map`` requires your input and output types to
+  ## be the same, since they are modified in-place. Example:
+  ##
+  ## .. code-block:: nimrod
+  ##   var a = @["1", "2", "3", "4"]
+  ##   echo repr(a)
+  ##   # --> ["1", "2", "3", "4"]
+  ##   map(a, proc(x: var string) = x &= "42")
+  ##   echo repr(a)
+  ##   # --> ["142", "242", "342", "442"]
   for i in 0..data.len-1: op(data[i])
 
 iterator fields*[T: tuple](x: T): TObject {.
diff --git a/tests/compile/tclosure4.nim b/tests/compile/tclosure4.nim
index 9584fa98a..8e08376b6 100644
--- a/tests/compile/tclosure4.nim
+++ b/tests/compile/tclosure4.nim
@@ -4,8 +4,8 @@ import json, tables
 proc run(json_params: TTable) =
   let json_elems = json_params["files"].elems
   # These fail compilation.
-  var files = each(json_elems, proc (x: PJsonNode): string = x.str)
-  #var files = json_elems.each do (x: PJsonNode) -> string: x.str
+  var files = map(json_elems, proc (x: PJsonNode): string = x.str)
+  #var files = json_elems.map do (x: PJsonNode) -> string: x.str
   echo "Hey!"
 
 when isMainModule:
diff --git a/tests/compile/toverprc.nim b/tests/compile/toverprc.nim
index 43271b684..f3aa66b80 100755
--- a/tests/compile/toverprc.nim
+++ b/tests/compile/toverprc.nim
@@ -21,7 +21,7 @@ proc takeParseInt(x: proc (y: string): int {.noSideEffect.}): int =
   result = x("123")
   
 echo "Give a list of numbers (separated by spaces): "
-var x = stdin.readline.split.each(parseInt).max
+var x = stdin.readline.split.map(parseInt).max
 echo x, " is the maximum!"
 echo "another number: ", takeParseInt(parseInt)
 
diff --git a/web/index.txt b/web/index.txt
index 207e425ae..99beb3743 100755
--- a/web/index.txt
+++ b/web/index.txt
@@ -33,7 +33,7 @@ from that model.
     # Prints the maximum integer from a list of integers
     # delimited by whitespace read from stdin.
     let tokens = stdin.readLine.split
-    echo tokens.each(parseInt).max, " is the maximum."
+    echo tokens.map(parseInt).max, " is the maximum."
 
 
 Nimrod is efficient