Move FromStr to core::str

Author: brendanzab

src/compiletest/common.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::from_str::FromStr;
 use std::fmt;
+use std::str::FromStr;
 use regex::Regex;
 
 #[deriving(Clone, PartialEq)]

src/compiletest/compiletest.rs

@@ -22,7 +22,7 @@ extern crate regex;
 use std::os;
 use std::io;
 use std::io::fs;
-use std::from_str::FromStr;
+use std::str::FromStr;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
 use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};

src/compiletest/header.rs

@@ -12,8 +12,6 @@ use common::Config;
 use common;
 use util;
 
-use std::from_str::FromStr;
-
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     pub error_patterns: Vec<String> ,
@@ -353,8 +351,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = FromStr::from_str(components[0]).expect(error_string);
-    let minor: int = FromStr::from_str(components[1]).expect(error_string);
+    let major: int = from_str(components[0]).expect(error_string);
+    let minor: int = from_str(components[1]).expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -364,6 +362,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = FromStr::from_str(version_string).expect(error_string);
+    let major: int = from_str(version_string).expect(error_string);
     return major;
 }

src/doc/reference.md

@@ -3108,11 +3108,10 @@ then the expression completes.
 Some examples of call expressions:
 
 ```
-# use std::from_str::FromStr;
 # fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);
-let pi: Option<f32> = FromStr::from_str("3.14");
+let pi: Option<f32> = from_str("3.14");
 ```
 
 ### Lambda expressions

src/libcollections/str.rs

@@ -73,6 +73,7 @@ pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
 pub use core::str::{Utf16CodeUnits, eq_slice, is_utf8, is_utf16, Utf16Items};
 pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
 pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
+pub use core::str::{FromStr, from_str};
 pub use core::str::{Str, StrPrelude};
 pub use unicode::str::{UnicodeStrPrelude, Words, Graphemes, GraphemeIndices};
 

src/libcollections/string.rs

@@ -25,7 +25,7 @@ use core::raw::Slice as RawSlice;
 use hash;
 use slice::CloneSliceAllocPrelude;
 use str;
-use str::{CharRange, StrAllocating, MaybeOwned, Owned};
+use str::{CharRange, FromStr, StrAllocating, MaybeOwned, Owned};
 use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
 use vec::{DerefVec, Vec, as_vec};
 
@@ -795,6 +795,13 @@ pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
     DerefString { x: as_vec(x.as_bytes()) }
 }
 
+impl FromStr for String {
+    #[inline]
+    fn from_str(s: &str) -> Option<String> {
+        Some(String::from_str(s))
+    }
+}
+
 /// Unsafe operations
 #[unstable = "waiting on raw module conventions"]
 pub mod raw {

src/libcore/num/f32.rs

@@ -17,7 +17,9 @@
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
-use num::Float;
+use num::{Float, FromStrRadix};
+use num::strconv;
+use str::FromStr;
 use option::Option;
 
 pub const RADIX: uint = 2u;
@@ -424,3 +426,66 @@ impl Float for f32 {
         self * (value / 180.0f32)
     }
 }
+
+#[inline]
+#[allow(missing_docs)]
+#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
+pub fn from_str_hex(src: &str) -> Option<f32> {
+    strconv::from_str_radix_float(src, 16)
+}
+
+impl FromStr for f32 {
+    /// Convert a string in base 10 to a float.
+    /// Accepts an optional decimal exponent.
+    ///
+    /// This function accepts strings such as
+    ///
+    /// * '3.14'
+    /// * '+3.14', equivalent to '3.14'
+    /// * '-3.14'
+    /// * '2.5E10', or equivalently, '2.5e10'
+    /// * '2.5E-10'
+    /// * '.' (understood as 0)
+    /// * '5.'
+    /// * '.5', or, equivalently,  '0.5'
+    /// * '+inf', 'inf', '-inf', 'NaN'
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number.  Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str(src: &str) -> Option<f32> {
+        strconv::from_str_radix_float(src, 10u)
+    }
+}
+
+impl FromStrRadix for f32 {
+    /// Convert a string in a given base to a float.
+    ///
+    /// Due to possible conflicts, this function does **not** accept
+    /// the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
+    /// does it recognize exponents of any kind.
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    /// * radix - The base to use. Must lie in the range [2 .. 36]
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number. Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str_radix(src: &str, radix: uint) -> Option<f32> {
+        strconv::from_str_radix_float(src, radix)
+    }
+}

src/libcore/num/f64.rs

@@ -17,7 +17,9 @@
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
-use num::Float;
+use num::{Float, FromStrRadix};
+use num::strconv;
+use str::FromStr;
 use option::Option;
 
 // FIXME(#5527): These constants should be deprecated once associated
@@ -430,3 +432,61 @@ impl Float for f64 {
         self * (value / 180.0)
     }
 }
+
+#[inline]
+#[allow(missing_docs)]
+#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
+pub fn from_str_hex(src: &str) -> Option<f64> {
+    strconv::from_str_radix_float(src, 16)
+}
+
+impl FromStr for f64 {
+    /// Convert a string in base 10 to a float.
+    /// Accepts an optional decimal exponent.
+    ///
+    /// This function accepts strings such as:
+    ///
+    /// * '3.14'
+    /// * '-3.14'
+    /// * '2.5E10', or equivalently, '2.5e10'
+    /// * '2.5E-10'
+    /// * '.' (understood as 0)
+    /// * '5.'
+    /// * '.5', or, equivalently,  '0.5'
+    /// * inf', '-inf', 'NaN'
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    ///
+    /// # Return value
+    ///
+    /// `none` if the string did not represent a valid number.  Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str(src: &str) -> Option<f64> {
+        strconv::from_str_radix_float(src, 10u)
+    }
+}
+
+impl FromStrRadix for f64 {
+    /// Convert a string in a given base to a float.
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    /// * radix - The base to use. Must lie in the range [2 .. 36]
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number. Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str_radix(src: &str, radix: uint) -> Option<f64> {
+        strconv::from_str_radix_float(src, radix)
+    }
+}

src/libcore/num/int_macros.rs

@@ -32,4 +32,20 @@ pub const MIN: $T = (-1 as $T) << (BITS - 1);
 #[unstable]
 pub const MAX: $T = !MIN;
 
+#[experimental = "might need to return Result"]
+impl ::str::FromStr for $T {
+    #[inline]
+    fn from_str(s: &str) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, 10)
+    }
+}
+
+#[experimental = "might need to return Result"]
+impl ::num::FromStrRadix for $T {
+    #[inline]
+    fn from_str_radix(s: &str, radix: uint) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, radix)
+    }
+}
+
 ))

src/libcore/num/mod.rs

@@ -27,6 +27,8 @@ use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::{Option, Some, None};
 
+pub mod strconv;
+
 /// Simultaneous division and remainder
 #[inline]
 pub fn div_rem<T: Div<T, T> + Rem<T, T>>(x: T, y: T) -> (T, T) {
@@ -1372,6 +1374,18 @@ pub trait Float
     fn to_radians(self) -> Self;
 }
 
+/// A generic trait for converting a string with a radix (base) to a value
+#[experimental = "might need to return Result"]
+pub trait FromStrRadix {
+    fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
+}
+
+/// A utility function that just calls FromStrRadix::from_str_radix.
+#[experimental = "might need to return Result"]
+pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
+    FromStrRadix::from_str_radix(str, radix)
+}
+
 // DEPRECATED
 
 macro_rules! trait_impl {