https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=1.26.2 2015-04-01T15:22:39+00:00 2015-04-01T15:22:39+00:00 Niko Matsakis niko@alum.mit.edu 2015-03-30T13:38:27+00:00 urn:sha1:890ed5c46847fa544278c18fd46c1bdfe2809c09 2015-01-29T12:49:02+00:00 Jorge Aparicio japaricious@gmail.com 2015-01-28T13:34:18+00:00 urn:sha1:788181d4055747b5307f186a873ab5d2acd29994 2015-01-25T16:20:38+00:00 Jorge Aparicio japaricious@gmail.com 2015-01-24T21:36:30+00:00 urn:sha1:bff462302b3e0a8f68c14cad2806c7ff5005364e 2015-01-06T22:49:42+00:00 Sean McArthur sean.monstar@gmail.com 2014-12-20T08:09:35+00:00 urn:sha1:44440e5c18a1dbcc9685866ffffe00c508929079 fmt::Show is for debugging, and can and should be implemented for all public types. This trait is used with `{:?}` syntax. There still exists #[derive(Show)]. fmt::String is for types that faithfully be represented as a String. Because of this, there is no way to derive fmt::String, all implementations must be purposeful. It is used by the default format syntax, `{}`. This will break most instances of `{}`, since that now requires the type to impl fmt::String. In most cases, replacing `{}` with `{:?}` is the correct fix. Types that were being printed specifically for users should receive a fmt::String implementation to fix this. Part of #20013 [breaking-change] 2015-01-06T02:21:14+00:00 Keegan McAllister kmcallister@mozilla.com 2015-01-03T03:41:40+00:00 urn:sha1:c2e26972e307a2e82b9ff7a5345a5bff47a99501 2015-01-02T10:05:22+00:00 Nick Cameron ncameron@mozilla.com 2014-12-31T04:32:49+00:00 urn:sha1:30e149231c627e61524d1b5bd6357886befae9e6 2014-12-08T18:47:44+00:00 Niko Matsakis niko@alum.mit.edu 2014-12-06T01:01:33+00:00 urn:sha1:096a28607fb80c91e6e2ca64d9ef44c4e550e96c This change makes the compiler no longer infer whether types (structures and enumerations) implement the `Copy` trait (and thus are implicitly copyable). Rather, you must implement `Copy` yourself via `impl Copy for MyType {}`. A new warning has been added, `missing_copy_implementations`, to warn you if a non-generic public type has been added that could have implemented `Copy` but didn't. For convenience, you may *temporarily* opt out of this behavior by using `#![feature(opt_out_copy)]`. Note though that this feature gate will never be accepted and will be removed by the time that 1.0 is released, so you should transition your code away from using it. This breaks code like: #[deriving(Show)] struct Point2D { x: int, y: int, } fn main() { let mypoint = Point2D { x: 1, y: 1, }; let otherpoint = mypoint; println!("{}{}", mypoint, otherpoint); } Change this code to: #[deriving(Show)] struct Point2D { x: int, y: int, } impl Copy for Point2D {} fn main() { let mypoint = Point2D { x: 1, y: 1, }; let otherpoint = mypoint; println!("{}{}", mypoint, otherpoint); } This is the backwards-incompatible part of #13231. Part of RFC #3. [breaking-change] 2014-11-17T15:35:51+00:00 Steven Fackler sfackler@gmail.com 2014-11-06T08:05:53+00:00 urn:sha1:3dcd2157403163789aaf21a9ab3c4d30a7c6494d This breaks code that referred to variant names in the same namespace as their enum. Reexport the variants in the old location or alter code to refer to the new locations: ``` pub enum Foo { A, B } fn main() { let a = A; } ``` => ``` pub use self::Foo::{A, B}; pub enum Foo { A, B } fn main() { let a = A; } ``` or ``` pub enum Foo { A, B } fn main() { let a = Foo::A; } ``` [breaking-change] 2014-10-16T15:15:34+00:00 Luqman Aden laden@csclub.uwaterloo.ca 2014-10-15T01:07:11+00:00 urn:sha1:38aca17c474321e4c260e36f173275a90d753397 2014-06-29T18:47:58+00:00 Patrick Walton pcwalton@mimiga.net 2014-06-27T19:30:25+00:00 urn:sha1:a5bb0a3a4574af88add700ace7aefc37172fa7a5 floating point numbers for real. This will break code that looks like: let mut x = 0; while ... { x += 1; } println!("{}", x); Change that code to: let mut x = 0i; while ... { x += 1; } println!("{}", x); Closes #15201. [breaking-change]