---

yaml
---
r: 14836
b: refs/heads/try
c: 7c70d35
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 9086c6f5a2ac3e09c358d05700bfbcb18378bdf6
+refs/heads/try: 7c70d35a10d7157b4a31ac1db18afe96268735f6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/libcore/result.rs

@@ -89,6 +89,86 @@ fn chain<T, U: copy, V: copy>(res: result<T, V>, op: fn(T) -> result<U, V>)
     }
 }
 
+// ______________________________________________________________________
+// Note:
+//
+// These helper functions are written in a "pre-chained" (a.k.a,
+// deforested) style because I have found that, in practice, this is
+// the most concise way to do things.  That means that they do not not
+// terminate with a call to `ok(v)` but rather `nxt(v)`.  If you would
+// like to just get the result, just pass in `ok` as `nxt`.
+
+#[doc = "
+Maps each element in the vector `ts` using the operation `op`.  Should an
+error occur, no further mappings are performed and the error is returned.
+Should no error occur, a vector containing the result of each map is
+passed to the `nxt` function.
+
+Here is an example which increments every integer in a vector,
+checking for overflow:
+
+    fn inc_conditionally(x: uint) -> result<uint,str> {
+        if x == uint::max_value { ret err(\"overflow\"); }
+        else { ret ok(x+1u); }
+    }
+    map([1u, 2u, 3u], inc_conditionally) {|incd|
+        assert incd == [2u, 3u, 4u];
+    }
+
+Note: if you have to combine a deforested style transform with map,
+you should use `ok` for the `nxt` operation, as shown here (this is an
+alternate version of the previous example where the
+`inc_conditionally()` routine is deforested):
+
+    fn inc_conditionally<T>(x: uint,
+                            nxt: fn(uint) -> result<T,str>) -> result<T,str> {
+        if x == uint::max_value { ret err(\"overflow\"); }
+        else { ret nxt(x+1u); }
+    }
+    map([1u, 2u, 3u], inc_conditionally(_, ok)) {|incd|
+        assert incd == [2u, 3u, 4u];
+    }
+"]
+fn map<T,U:copy,V:copy,W>(ts: [T],
+                          op: fn(T) -> result<V,U>,
+                          nxt: fn([V]) -> result<W,U>) -> result<W,U> {
+    let mut vs: [V] = [];
+    vec::reserve(vs, vec::len(ts));
+    for t in ts {
+        alt op(t) {
+          ok(v) { vs += [v]; }
+          err(u) { ret err(u); }
+        }
+    }
+    ret nxt(vs);
+}
+
+#[doc = "Same as map, but it operates over two parallel vectors.
+
+A precondition is used here to ensure that the vectors are the same
+length.  While we do not often use preconditions in the standard
+library, a precondition is used here because result::t is generally
+used in 'careful' code contexts where it is both appropriate and easy
+to accommodate an error like the vectors being of different lengths."]
+fn map2<S,T,U:copy,V:copy,W>(ss: [S], ts: [T],
+                             op: fn(S,T) -> result<V,U>,
+                             nxt: fn([V]) -> result<W,U>)
+    : vec::same_length(ss, ts)
+    -> result<W,U> {
+    let n = vec::len(ts);
+    let mut vs = [];
+    vec::reserve(vs, n);
+    let mut i = 0u;
+    while i < n {
+        alt op(ss[i],ts[i]) {
+          ok(v) { vs += [v]; }
+          err(u) { ret err(u); }
+        }
+        i += 1u;
+    }
+    ret nxt(vs);
+}
+
 #[cfg(test)]
 mod tests {
     fn op1() -> result::result<int, str> { result::ok(666) }