---

yaml
---
r: 95137
b: refs/heads/dist-snap
c: c463772
h: refs/heads/master
i:
  95135: 9e567f9
v: v3

Author: luisbg

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: c44826fdcd036982b955407677c5ec4ce1f834ce
+refs/heads/dist-snap: c463772ebdbfca65017ac1bc2c8322d229b291a9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -363,17 +363,19 @@ A _floating-point literal_ has one of two forms:
   second decimal literal.
 * A single _decimal literal_ followed by an _exponent_.
 
-By default, a floating-point literal has a generic type, but will fall back to
-`f64`. A floating-point literal may be followed (immediately, without any
-spaces) by a _floating-point suffix_, which changes the type of the literal.
-There are two floating-point suffixes: `f32`, and `f64` (the 32-bit and 64-bit
-floating point types).
+By default, a floating-point literal is of type `float`. A
+floating-point literal may be followed (immediately, without any
+spaces) by a _floating-point suffix_, which changes the type of the
+literal. There are three floating-point suffixes: `f` (for the base
+`float` type), `f32`, and `f64` (the 32-bit and 64-bit floating point
+types).
 
 Examples of floating-point literals of various forms:
 
 ~~~~
-123.0;                             // type f64
-0.1;                               // type f64
+123.0;                             // type float
+0.1;                               // type float
+3f;                                // type float
 0.1f32;                            // type f32
 12E+99_f64;                        // type f64
 ~~~~
@@ -1177,8 +1179,8 @@ a = Cat;
 Enumeration constructors can have either named or unnamed fields:
 ~~~~
 enum Animal {
-    Dog (~str, f64),
-    Cat { name: ~str, weight: f64 }
+    Dog (~str, float),
+    Cat { name: ~str, weight: float }
 }
 
 let mut a: Animal = Dog(~"Cocoa", 37.2);
@@ -1342,17 +1344,17 @@ For example:
 trait Num {
     fn from_int(n: int) -> Self;
 }
-impl Num for f64 {
-    fn from_int(n: int) -> f64 { n as f64 }
+impl Num for float {
+    fn from_int(n: int) -> float { n as float }
 }
-let x: f64 = Num::from_int(42);
+let x: float = Num::from_int(42);
 ~~~~
 
 Traits may inherit from other traits. For example, in
 
 ~~~~
-trait Shape { fn area() -> f64; }
-trait Circle : Shape { fn radius() -> f64; }
+trait Shape { fn area() -> float; }
+trait Circle : Shape { fn radius() -> float; }
 ~~~~
 
 the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
@@ -1365,9 +1367,9 @@ methods of the supertrait may be called on values of subtrait-bound type paramet
 Referring to the previous example of `trait Circle : Shape`:
 
 ~~~
-# trait Shape { fn area(&self) -> f64; }
-# trait Circle : Shape { fn radius(&self) -> f64; }
-fn radius_times_area<T: Circle>(c: T) -> f64 {
+# trait Shape { fn area(&self) -> float; }
+# trait Circle : Shape { fn radius(&self) -> float; }
+fn radius_times_area<T: Circle>(c: T) -> float {
     // `c` is both a Circle and a Shape
     c.radius() * c.area()
 }
@@ -1376,10 +1378,10 @@ fn radius_times_area<T: Circle>(c: T) -> f64 {
 Likewise, supertrait methods may also be called on trait objects.
 
 ~~~ {.xfail-test}
-# trait Shape { fn area(&self) -> f64; }
-# trait Circle : Shape { fn radius(&self) -> f64; }
-# impl Shape for int { fn area(&self) -> f64 { 0.0 } }
-# impl Circle for int { fn radius(&self) -> f64 { 0.0 } }
+# trait Shape { fn area(&self) -> float; }
+# trait Circle : Shape { fn radius(&self) -> float; }
+# impl Shape for int { fn area(&self) -> float { 0.0 } }
+# impl Circle for int { fn radius(&self) -> float { 0.0 } }
 # let mycircle = 0;
 
 let mycircle: Circle = @mycircle as @Circle;
@@ -1393,14 +1395,14 @@ An _implementation_ is an item that implements a [trait](#traits) for a specific
 Implementations are defined with the keyword `impl`.
 
 ~~~~
-# struct Point {x: f64, y: f64};
+# struct Point {x: float, y: float};
 # type Surface = int;
-# struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
+# struct BoundingBox {x: float, y: float, width: float, height: float};
 # trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }
 # fn do_draw_circle(s: Surface, c: Circle) { }
 
 struct Circle {
-    radius: f64,
+    radius: float,
     center: Point,
 }
 
@@ -1968,7 +1970,7 @@ values.
 
 ~~~~~~~~ {.tuple}
 (0,);
-(0.0, 4.5);
+(0f, 4.5f);
 ("a", 4u, true);
 ~~~~~~~~
 
@@ -2000,12 +2002,12 @@ A _unit-like structure expression_ consists only of the [path](#paths) of a [str
 The following are examples of structure expressions:
 
 ~~~~
-# struct Point { x: f64, y: f64 }
-# struct TuplePoint(f64, f64);
+# struct Point { x: float, y: float }
+# struct TuplePoint(float, float);
 # mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
 # struct Cookie; fn some_fn<T>(t: T) {}
-Point {x: 10.0, y: 20.0};
-TuplePoint(10.0, 20.0);
+Point {x: 10f, y: 20f};
+TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35, score: 100_000};
 some_fn::<Cookie>(Cookie);
 ~~~~
@@ -2246,12 +2248,12 @@ Any other cast is unsupported and will fail to compile.
 An example of an `as` expression:
 
 ~~~~
-# fn sum(v: &[f64]) -> f64 { 0.0 }
-# fn len(v: &[f64]) -> int { 0 }
+# fn sum(v: &[float]) -> float { 0.0 }
+# fn len(v: &[float]) -> int { 0 }
 
-fn avg(v: &[f64]) -> f64 {
-  let sum: f64 = sum(v);
-  let sz: f64 = len(v) as f64;
+fn avg(v: &[float]) -> float {
+  let sum: float = sum(v);
+  let sz: float = len(v) as float;
   return sum / sz;
 }
 ~~~~
@@ -2765,6 +2767,19 @@ size, in bits, is equal to the size of the rust type `uint` on the same target
 machine.
 
 
+#### Machine-dependent floating point type
+
+The Rust type `float` is a machine-specific type equal to one of the supported
+Rust floating-point machine types (`f32` or `f64`). It is the largest
+floating-point type that is directly supported by hardware on the target
+machine, or if the target machine has no floating-point hardware support, the
+largest floating-point type supported by the software floating-point library
+used to support the other floating-point machine types.
+
+Note that due to the preference for hardware-supported floating-point, the
+type `float` may not be equal to the largest *supported* floating-point type.
+
+
 ### Textual types
 
 The types `char` and `str` hold textual data.