De-export iter and result. Part of #3583.
This commit is contained in:
Graydon Hoare
parent
24fbf88230
commit
39f114d171
@ -185,7 +185,6 @@ mod cmp;
|
||||
mod num;
|
||||
mod hash;
|
||||
mod either;
|
||||
#[legacy_exports]
|
||||
mod iter;
|
||||
mod logging;
|
||||
mod option;
|
||||
@ -194,7 +193,6 @@ mod option_iter {
|
||||
#[path = "option.rs"]
|
||||
mod inst;
|
||||
}
|
||||
#[legacy_exports]
|
||||
mod result;
|
||||
mod to_str;
|
||||
mod to_bytes;
|
||||
|
||||
@ -7,14 +7,14 @@ The iteration traits and common implementation
|
||||
use cmp::{Eq, Ord};
|
||||
|
||||
/// A function used to initialize the elements of a sequence
|
||||
type InitOp<T> = &fn(uint) -> T;
|
||||
pub type InitOp<T> = &fn(uint) -> T;
|
||||
|
||||
trait BaseIter<A> {
|
||||
pub trait BaseIter<A> {
|
||||
pure fn each(blk: fn(v: &A) -> bool);
|
||||
pure fn size_hint() -> Option<uint>;
|
||||
}
|
||||
|
||||
trait ExtendedIter<A> {
|
||||
pub trait ExtendedIter<A> {
|
||||
pure fn eachi(blk: fn(uint, v: &A) -> bool);
|
||||
pure fn all(blk: fn(&A) -> bool) -> bool;
|
||||
pure fn any(blk: fn(&A) -> bool) -> bool;
|
||||
@ -22,33 +22,34 @@ trait ExtendedIter<A> {
|
||||
pure fn position(f: fn(&A) -> bool) -> Option<uint>;
|
||||
}
|
||||
|
||||
trait EqIter<A:Eq> {
|
||||
pub trait EqIter<A:Eq> {
|
||||
pure fn contains(x: &A) -> bool;
|
||||
pure fn count(x: &A) -> uint;
|
||||
}
|
||||
|
||||
trait Times {
|
||||
pub trait Times {
|
||||
pure fn times(it: fn() -> bool);
|
||||
}
|
||||
trait TimesIx{
|
||||
|
||||
pub trait TimesIx{
|
||||
pure fn timesi(it: fn(uint) -> bool);
|
||||
}
|
||||
|
||||
trait CopyableIter<A:Copy> {
|
||||
pub trait CopyableIter<A:Copy> {
|
||||
pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
|
||||
pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
|
||||
pure fn to_vec() -> ~[A];
|
||||
pure fn find(p: fn(+a: A) -> bool) -> Option<A>;
|
||||
}
|
||||
|
||||
trait CopyableOrderedIter<A:Copy Ord> {
|
||||
pub trait CopyableOrderedIter<A:Copy Ord> {
|
||||
pure fn min() -> A;
|
||||
pure fn max() -> A;
|
||||
}
|
||||
|
||||
// A trait for sequences that can be by imperatively pushing elements
|
||||
// onto them.
|
||||
trait Buildable<A> {
|
||||
pub trait Buildable<A> {
|
||||
/**
|
||||
* Builds a buildable sequence by calling a provided function with
|
||||
* an argument function that pushes an element onto the back of
|
||||
@ -66,7 +67,8 @@ trait Buildable<A> {
|
||||
builder: fn(push: pure fn(+v: A))) -> self;
|
||||
}
|
||||
|
||||
pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
|
||||
pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA,
|
||||
blk: fn(uint, v: &A) -> bool) {
|
||||
let mut i = 0;
|
||||
for self.each |a| {
|
||||
if !blk(i, a) { break; }
|
||||
@ -74,22 +76,24 @@ pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
|
||||
}
|
||||
}
|
||||
|
||||
pure fn all<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
|
||||
pub pure fn all<A,IA:BaseIter<A>>(self: &IA,
|
||||
blk: fn(&A) -> bool) -> bool {
|
||||
for self.each |a| {
|
||||
if !blk(a) { return false; }
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
pure fn any<A,IA:BaseIter<A>>(self: &IA, blk: fn(&A) -> bool) -> bool {
|
||||
pub pure fn any<A,IA:BaseIter<A>>(self: &IA,
|
||||
blk: fn(&A) -> bool) -> bool {
|
||||
for self.each |a| {
|
||||
if blk(a) { return true; }
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: &IA,
|
||||
prd: fn(+a: A) -> bool) -> ~[A] {
|
||||
pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
|
||||
self: &IA, prd: fn(+a: A) -> bool) -> ~[A] {
|
||||
do vec::build_sized_opt(self.size_hint()) |push| {
|
||||
for self.each |a| {
|
||||
if prd(*a) { push(*a); }
|
||||
@ -97,7 +101,8 @@ pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(self: &IA,
|
||||
}
|
||||
}
|
||||
|
||||
pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA, op: fn(+v: A) -> B)
|
||||
pub pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA,
|
||||
op: fn(+v: A) -> B)
|
||||
-> ~[B] {
|
||||
do vec::build_sized_opt(self.size_hint()) |push| {
|
||||
for self.each |a| {
|
||||
@ -106,7 +111,7 @@ pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA, op: fn(+v: A) -> B)
|
||||
}
|
||||
}
|
||||
|
||||
pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
|
||||
pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
|
||||
self: &IA, op: fn(+a: A) -> IB) -> ~[B] {
|
||||
|
||||
do vec::build |push| {
|
||||
@ -118,7 +123,8 @@ pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
|
||||
}
|
||||
}
|
||||
|
||||
pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B, blk: fn(&B, &A) -> B)
|
||||
pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B,
|
||||
blk: fn(&B, &A) -> B)
|
||||
-> B {
|
||||
let mut b <- b0;
|
||||
for self.each |a| {
|
||||
@ -127,18 +133,18 @@ pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B, blk: fn(&B, &A) -> B)
|
||||
move b
|
||||
}
|
||||
|
||||
pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] {
|
||||
pub pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: &IA) -> ~[A] {
|
||||
foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy (*r), ~[*a]))
|
||||
}
|
||||
|
||||
pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool {
|
||||
pub pure fn contains<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> bool {
|
||||
for self.each |a| {
|
||||
if *a == *x { return true; }
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
|
||||
pub pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
|
||||
do foldl(self, 0) |count, value| {
|
||||
if *value == *x {
|
||||
*count + 1
|
||||
@ -148,7 +154,7 @@ pure fn count<A:Eq,IA:BaseIter<A>>(self: &IA, x: &A) -> uint {
|
||||
}
|
||||
}
|
||||
|
||||
pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
|
||||
pub pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
|
||||
-> Option<uint>
|
||||
{
|
||||
let mut i = 0;
|
||||
@ -163,7 +169,7 @@ pure fn position<A,IA:BaseIter<A>>(self: &IA, f: fn(&A) -> bool)
|
||||
// iter interface, such as would provide "reach" in addition to "each". as is,
|
||||
// it would have to be implemented with foldr, which is too inefficient.
|
||||
|
||||
pure fn repeat(times: uint, blk: fn() -> bool) {
|
||||
pub pure fn repeat(times: uint, blk: fn() -> bool) {
|
||||
let mut i = 0;
|
||||
while i < times {
|
||||
if !blk() { break }
|
||||
@ -171,7 +177,7 @@ pure fn repeat(times: uint, blk: fn() -> bool) {
|
||||
}
|
||||
}
|
||||
|
||||
pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
pub pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
|
||||
match a {
|
||||
&Some(ref a_) if *a_ < *b => {
|
||||
@ -185,7 +191,7 @@ pure fn min<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
}
|
||||
}
|
||||
|
||||
pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
pub pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
match do foldl::<A,Option<A>,IA>(self, None) |a, b| {
|
||||
match a {
|
||||
&Some(ref a_) if *a_ > *b => {
|
||||
@ -199,7 +205,7 @@ pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
|
||||
}
|
||||
}
|
||||
|
||||
pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
|
||||
pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
|
||||
p: fn(+a: A) -> bool) -> Option<A> {
|
||||
for self.each |i| {
|
||||
if p(*i) { return Some(*i) }
|
||||
@ -220,7 +226,8 @@ pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
|
||||
* onto the sequence being constructed.
|
||||
*/
|
||||
#[inline(always)]
|
||||
pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A))) -> B {
|
||||
pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A)))
|
||||
-> B {
|
||||
build_sized(4, builder)
|
||||
}
|
||||
|
||||
@ -238,7 +245,7 @@ pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A))) -> B {
|
||||
* onto the sequence being constructed.
|
||||
*/
|
||||
#[inline(always)]
|
||||
pure fn build_sized_opt<A,B: Buildable<A>>(
|
||||
pub pure fn build_sized_opt<A,B: Buildable<A>>(
|
||||
size: Option<uint>,
|
||||
builder: fn(push: pure fn(+v: A))) -> B {
|
||||
|
||||
@ -248,7 +255,8 @@ pure fn build_sized_opt<A,B: Buildable<A>>(
|
||||
// Functions that combine iteration and building
|
||||
|
||||
/// Apply a function to each element of an iterable and return the results
|
||||
fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U) -> BU {
|
||||
pub fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U)
|
||||
-> BU {
|
||||
do build_sized_opt(v.size_hint()) |push| {
|
||||
for v.each() |elem| {
|
||||
push(f(elem));
|
||||
@ -262,7 +270,8 @@ fn map<T,IT: BaseIter<T>,U,BU: Buildable<U>>(v: &IT, f: fn(&T) -> U) -> BU {
|
||||
* Creates a generic sequence of size `n_elts` and initializes the elements
|
||||
* to the value returned by the function `op`.
|
||||
*/
|
||||
pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint, op: InitOp<T>) -> BT {
|
||||
pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
|
||||
op: InitOp<T>) -> BT {
|
||||
do build_sized(n_elts) |push| {
|
||||
let mut i: uint = 0u;
|
||||
while i < n_elts { push(op(i)); i += 1u; }
|
||||
@ -275,7 +284,8 @@ pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint, op: InitOp<T>) -> BT {
|
||||
* Creates an immutable vector of size `n_elts` and initializes the elements
|
||||
* to the value `t`.
|
||||
*/
|
||||
pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint, +t: T) -> BT {
|
||||
pub pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint,
|
||||
+t: T) -> BT {
|
||||
do build_sized(n_elts) |push| {
|
||||
let mut i: uint = 0;
|
||||
while i < n_elts { push(t); i += 1; }
|
||||
@ -284,7 +294,7 @@ pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint, +t: T) -> BT {
|
||||
|
||||
/// Appending two generic sequences
|
||||
#[inline(always)]
|
||||
pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
|
||||
pub pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
|
||||
lhs: &IT, rhs: &IT) -> BT {
|
||||
let size_opt = lhs.size_hint().chain_ref(
|
||||
|sz1| rhs.size_hint().map(|sz2| *sz1+*sz2));
|
||||
@ -297,7 +307,7 @@ pure fn append<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
|
||||
/// Copies a generic sequence, possibly converting it to a different
|
||||
/// type of sequence.
|
||||
#[inline(always)]
|
||||
pure fn copy_seq<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
|
||||
pub pure fn copy_seq<T: Copy,IT: BaseIter<T>,BT: Buildable<T>>(
|
||||
v: &IT) -> BT {
|
||||
do build_sized_opt(v.size_hint()) |push| {
|
||||
for v.each |x| { push(*x); }
|
||||
|
||||
@ -8,7 +8,7 @@ use cmp::Eq;
|
||||
use either::Either;
|
||||
|
||||
/// The result type
|
||||
enum Result<T, U> {
|
||||
pub enum Result<T, U> {
|
||||
/// Contains the successful result value
|
||||
Ok(T),
|
||||
/// Contains the error value
|
||||
@ -22,7 +22,7 @@ enum Result<T, U> {
|
||||
*
|
||||
* If the result is an error
|
||||
*/
|
||||
pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
|
||||
pub pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
|
||||
match *res {
|
||||
Ok(copy t) => t,
|
||||
Err(ref the_err) => unsafe {
|
||||
@ -38,7 +38,7 @@ pure fn get<T: Copy, U>(res: &Result<T, U>) -> T {
|
||||
*
|
||||
* If the result is an error
|
||||
*/
|
||||
pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
|
||||
pub pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
|
||||
match *res {
|
||||
Ok(ref t) => t,
|
||||
Err(ref the_err) => unsafe {
|
||||
@ -54,7 +54,7 @@ pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
|
||||
*
|
||||
* If the result is not an error
|
||||
*/
|
||||
pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
|
||||
pub pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
|
||||
match *res {
|
||||
Err(copy u) => u,
|
||||
Ok(_) => fail ~"get_err called on ok result"
|
||||
@ -62,7 +62,7 @@ pure fn get_err<T, U: Copy>(res: &Result<T, U>) -> U {
|
||||
}
|
||||
|
||||
/// Returns true if the result is `ok`
|
||||
pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
|
||||
pub pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
|
||||
match *res {
|
||||
Ok(_) => true,
|
||||
Err(_) => false
|
||||
@ -70,7 +70,7 @@ pure fn is_ok<T, U>(res: &Result<T, U>) -> bool {
|
||||
}
|
||||
|
||||
/// Returns true if the result is `err`
|
||||
pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
|
||||
pub pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
|
||||
!is_ok(res)
|
||||
}
|
||||
|
||||
@ -80,7 +80,8 @@ pure fn is_err<T, U>(res: &Result<T, U>) -> bool {
|
||||
* `ok` result variants are converted to `either::right` variants, `err`
|
||||
* result variants are converted to `either::left`.
|
||||
*/
|
||||
pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>) -> Either<T, U> {
|
||||
pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
|
||||
-> Either<T, U> {
|
||||
match *res {
|
||||
Ok(copy res) => either::Right(res),
|
||||
Err(copy fail_) => either::Left(fail_)
|
||||
@ -101,7 +102,7 @@ pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>) -> Either<T, U> {
|
||||
* ok(parse_bytes(buf))
|
||||
* }
|
||||
*/
|
||||
fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
|
||||
pub fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
|
||||
-> Result<U, V>) -> Result<U, V> {
|
||||
// XXX: Should be writable with move + match
|
||||
if res.is_ok() {
|
||||
@ -119,7 +120,7 @@ fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
|
||||
* immediately returned. This function can be used to pass through a
|
||||
* successful result while handling an error.
|
||||
*/
|
||||
fn chain_err<T: Copy, U: Copy, V: Copy>(
|
||||
pub fn chain_err<T: Copy, U: Copy, V: Copy>(
|
||||
+res: Result<T, V>,
|
||||
op: fn(+t: V) -> Result<T, U>)
|
||||
-> Result<T, U> {
|
||||
@ -143,7 +144,7 @@ fn chain_err<T: Copy, U: Copy, V: Copy>(
|
||||
* print_buf(buf)
|
||||
* }
|
||||
*/
|
||||
fn iter<T, E>(res: &Result<T, E>, f: fn((&T))) {
|
||||
pub fn iter<T, E>(res: &Result<T, E>, f: fn((&T))) {
|
||||
match *res {
|
||||
Ok(ref t) => f(t),
|
||||
Err(_) => ()
|
||||
@ -158,7 +159,7 @@ fn iter<T, E>(res: &Result<T, E>, f: fn((&T))) {
|
||||
* This function can be used to pass through a successful result while
|
||||
* handling an error.
|
||||
*/
|
||||
fn iter_err<T, E>(res: &Result<T, E>, f: fn((&E))) {
|
||||
pub fn iter_err<T, E>(res: &Result<T, E>, f: fn((&E))) {
|
||||
match *res {
|
||||
Ok(_) => (),
|
||||
Err(ref e) => f(e)
|
||||
@ -179,7 +180,7 @@ fn iter_err<T, E>(res: &Result<T, E>, f: fn((&E))) {
|
||||
* parse_bytes(buf)
|
||||
* }
|
||||
*/
|
||||
fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn((&T)) -> U)
|
||||
pub fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn((&T)) -> U)
|
||||
-> Result<U, E> {
|
||||
match *res {
|
||||
Ok(ref t) => Ok(op(t)),
|
||||
@ -195,7 +196,7 @@ fn map<T, E: Copy, U: Copy>(res: &Result<T, E>, op: fn((&T)) -> U)
|
||||
* is immediately returned. This function can be used to pass through a
|
||||
* successful result while handling an error.
|
||||
*/
|
||||
fn map_err<T: Copy, E, F: Copy>(res: &Result<T, E>, op: fn((&E)) -> F)
|
||||
pub fn map_err<T: Copy, E, F: Copy>(res: &Result<T, E>, op: fn((&E)) -> F)
|
||||
-> Result<T, F> {
|
||||
match *res {
|
||||
Ok(copy t) => Ok(t),
|
||||
@ -274,7 +275,7 @@ impl<T: Copy, E: Copy> Result<T, E> {
|
||||
* assert incd == ~[2u, 3u, 4u];
|
||||
* }
|
||||
*/
|
||||
fn map_vec<T,U:Copy,V:Copy>(
|
||||
pub fn map_vec<T,U:Copy,V:Copy>(
|
||||
ts: &[T], op: fn((&T)) -> Result<V,U>) -> Result<~[V],U> {
|
||||
|
||||
let mut vs: ~[V] = vec::with_capacity(vec::len(ts));
|
||||
@ -287,7 +288,7 @@ fn map_vec<T,U:Copy,V:Copy>(
|
||||
return Ok(move vs);
|
||||
}
|
||||
|
||||
fn map_opt<T,U:Copy,V:Copy>(
|
||||
pub fn map_opt<T,U:Copy,V:Copy>(
|
||||
o_t: &Option<T>, op: fn((&T)) -> Result<V,U>) -> Result<Option<V>,U> {
|
||||
|
||||
match *o_t {
|
||||
@ -308,7 +309,7 @@ fn map_opt<T,U:Copy,V:Copy>(
|
||||
* used in 'careful' code contexts where it is both appropriate and easy
|
||||
* to accommodate an error like the vectors being of different lengths.
|
||||
*/
|
||||
fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
|
||||
pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
|
||||
op: fn((&S),(&T)) -> Result<V,U>) -> Result<~[V],U> {
|
||||
|
||||
assert vec::same_length(ss, ts);
|
||||
@ -330,7 +331,7 @@ fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
|
||||
* error. This could be implemented using `map2()` but it is more efficient
|
||||
* on its own as no result vector is built.
|
||||
*/
|
||||
fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
|
||||
pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
|
||||
op: fn((&S),(&T)) -> Result<(),U>) -> Result<(),U> {
|
||||
|
||||
assert vec::same_length(ss, ts);
|
||||
@ -347,7 +348,7 @@ fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
|
||||
}
|
||||
|
||||
/// Unwraps a result, assuming it is an `ok(T)`
|
||||
fn unwrap<T, U>(+res: Result<T, U>) -> T {
|
||||
pub fn unwrap<T, U>(+res: Result<T, U>) -> T {
|
||||
match move res {
|
||||
Ok(move t) => move t,
|
||||
Err(_) => fail ~"unwrap called on an err result"
|
||||
@ -355,7 +356,7 @@ fn unwrap<T, U>(+res: Result<T, U>) -> T {
|
||||
}
|
||||
|
||||
/// Unwraps a result, assuming it is an `err(U)`
|
||||
fn unwrap_err<T, U>(+res: Result<T, U>) -> U {
|
||||
pub fn unwrap_err<T, U>(+res: Result<T, U>) -> U {
|
||||
match move res {
|
||||
Err(move u) => move u,
|
||||
Ok(_) => fail ~"unwrap called on an ok result"
|
||||
|
||||
Loading…
Reference in New Issue
Block a user