Commit Graph

829 Commits

Author SHA1 Message Date
bors
f0ca717c64 auto merge of #18475 : gamazeps/rust/toExtend, r=alexcrichton
Ensured that Extend & FromIterator are implemented for the libcollection.

Removed the fact that FromIterator had to be implemented in order to implement Extend, as it did not make sense for LruCache (it needs to be given a size and there are no Default for LruCache).

Changed the name from Extend to Extendable.

Part of #18424
2014-11-08 21:06:37 +00:00
bors
b80edf1d12 auto merge of #18740 : jbcrail/rust/implement-enum-set-len, r=alexcrichton
This commit adds the missing EnumSet method mentioned by @Gankro.

cc #18424
2014-11-08 16:41:39 +00:00
bors
fa2983a1b7 auto merge of #18735 : utkarshkukreti/rust/remove-unnecessary-to_string-from-vec-docs, r=huonw
I don't think they're needed.
2014-11-08 14:41:37 +00:00
gamazeps
a11f16739f Implements Extend for EnumSet and LruCache
Part of #18424
2014-11-08 15:02:09 +01:00
gamazeps
16c8cd931c Renamed Extendable to Extend
In order to upgrade, simply rename the Extendable trait to Extend in
your code

Part of #18424

[breaking-change]
2014-11-08 15:02:09 +01:00
Joseph Crail
12db4de554 Add tests for BitAnd and BitXor. 2014-11-07 18:46:29 -05:00
Joseph Crail
01b599eb34 Add BitXor to EnumSet. 2014-11-07 18:00:14 -05:00
Joseph Crail
e15a3903e0 Rename deprecated EnumSet methods in unit tests. 2014-11-07 17:55:39 -05:00
Joseph Crail
a79d4be39c Implement len() for EnumSet. 2014-11-07 16:08:43 -05:00
Utkarsh Kukreti
0741dd795a Remove unnecessary .to_string()s from Vec.swap_remove's doc example. 2014-11-07 17:34:32 +05:30
Simon Sapin
d8ab2f87c1 Add example impl in CLike docs. Fix 13752. 2014-11-06 18:16:18 -08:00
Simon Sapin
a22772d6a6 EnumSet assertion: better error message. 2014-11-06 18:16:17 -08:00
Simon Sapin
1fdb759527 Make EnumSet not silently corrupt data.
Assert at run time instead. Fixes #13756.

I’d rather have this be detected at compile-time, but I don’t know how to do that.
2014-11-06 18:15:59 -08:00
Alex Crichton
2655abdd39 fix EnumSet::is_subset
Fix by @Gankro!
2014-11-06 15:41:50 -08:00
Alex Crichton
8a25e071e8 rollup merge of #18605 : Gankro/collect-fruit 2014-11-06 13:29:31 -08:00
Alexis Beingessner
cf3b2e4fe6 Implement low-hanging fruit of collection conventions
* Renames/deprecates the simplest and most obvious methods
* Adds FIXME(conventions)s for outstanding work
* Marks "handled" methods as unstable

NOTE: the semantics of reserve and reserve_exact have changed!
Other methods have had their semantics changed as well, but in a
way that should obviously not typecheck if used incorrectly.

Lots of work and breakage to come, but this handles most of the core
APIs and most eggregious breakage. Future changes should *mostly* focus on
niche collections, APIs, or simply back-compat additions.

[breaking-change]
2014-11-06 12:25:44 -05:00
Aaron Turon
cfafc1b737 Prelude: rename and consolidate extension traits
This commit renames a number of extension traits for slices and string
slices, now that they have been refactored for DST. In many cases,
multiple extension traits could now be consolidated. Further
consolidation will be possible with generalized where clauses.

The renamings are consistent with the [new `-Prelude`
suffix](https://github.com/rust-lang/rfcs/pull/344). There are probably
a few more candidates for being renamed this way, but that is left for
API stabilization of the relevant modules.

Because this renames traits, it is a:

[breaking-change]

However, I do not expect any code that currently uses the standard
library to actually break.

Closes #17917
2014-11-06 08:03:18 -08:00
Jorge Aparicio
11f4baeafb Fix tests 2014-11-05 20:13:25 -05:00
Jorge Aparicio
1e5f311d16 Fix fallout of DSTifying PartialEq, PartialOrd, Eq, Ord 2014-11-05 20:12:14 -05:00
Niko Matsakis
33ef78fa8b Add impls of the comparison operators for fixed-length arrays of lengths 0...32 and repair various cases where slices and fixed-length arrays were being compared. 2014-11-05 09:15:28 -05:00
Niko Matsakis
4af52eee59 Repair various cases where values of distinct types were being operated
upon (e.g., `&int` added to `int`).
2014-11-05 09:15:28 -05:00
Patrick Walton
e8d6031c71 libsyntax: Forbid escapes in the inclusive range \x80-\xff in
Unicode characters and strings.

Use `\u0080`-`\u00ff` instead. ASCII/byte literals are unaffected.

This PR introduces a new function, `escape_default`, into the ASCII
module. This was necessary for the pretty printer to continue to
function.

RFC #326.

Closes #18062.

[breaking-change]
2014-11-04 14:58:11 -08:00
Alex Crichton
e5a8840033 rollup merge of #18519 : Gankro/collect-smash 2014-11-03 08:31:45 -08:00
Alexis Beingessner
112c8a966f refactor libcollections as part of collection reform
* Moves multi-collection files into their own directory, and splits them into seperate files
* Changes exports so that each collection has its own module
* Adds underscores to public modules and filenames to match standard naming conventions

(that is, treemap::{TreeMap, TreeSet} => tree_map::TreeMap, tree_set::TreeSet)

* Renames PriorityQueue to BinaryHeap
* Renames SmallIntMap to VecMap
* Miscellanious fallout fixes

[breaking-change]
2014-11-02 18:58:11 -05:00
bors
b87619e274 auto merge of #18456 : gamazeps/rust/issue18449, r=thestinger
Made the fact that rodata is a section of the executable more explicit
Closes #18449
2014-11-02 23:27:10 +00:00
Daniel Micay
fea985a0b5 bubble up out-of-memory errors from liballoc
This makes the low-level allocation API suitable for use cases where
out-of-memory conditions need to be handled.

Closes #18292

[breaking-change]
2014-11-01 19:23:20 -04:00
Alex Crichton
21ac985af4 collections: Remove all collections traits
As part of the collections reform RFC, this commit removes all collections
traits in favor of inherent methods on collections themselves. All methods
should continue to be available on all collections.

This is a breaking change with all of the collections traits being removed and
no longer being in the prelude. In order to update old code you should move the
trait implementations to inherent implementations directly on the type itself.

Note that some traits had default methods which will also need to be implemented
to maintain backwards compatibility.

[breaking-change]
cc #18424
2014-11-01 11:37:04 -07:00
gamazeps
4ee0c4f3fb DOC: improves the str type explanation
Closes #18449
2014-10-31 19:00:00 +01:00
Jorge Aparicio
1384a43db3 DSTify Hash
- The signature of the `*_equiv` methods of `HashMap` and similar structures
have changed, and now require one less level of indirection. Change your code
from:

```
hashmap.find_equiv(&"Hello");
hashmap.find_equiv(&&[0u8, 1, 2]);
```

to:

```
hashmap.find_equiv("Hello");
hashmap.find_equiv(&[0u8, 1, 2]);
```

- The generic parameter `T` of the `Hasher::hash<T>` method have become
`Sized?`. Downstream code must add `Sized?` to that method in their
implementations. For example:

```
impl Hasher<FnvState> for FnvHasher {
    fn hash<T: Hash<FnvState>>(&self, t: &T) -> u64 { /* .. */ }
}
```

must be changed to:

```
impl Hasher<FnvState> for FnvHasher {
    fn hash<Sized? T: Hash<FnvState>>(&self, t: &T) -> u64 { /* .. */ }
    //      ^^^^^^
}
```

[breaking-change]
2014-10-31 07:25:34 -05:00
Alex Crichton
c10c163377 rollup merge of #18445 : alexcrichton/index-mut
Conflicts:
	src/libcollections/vec.rs
2014-10-30 17:37:55 -07:00
Alex Crichton
00975e041d rollup merge of #18398 : aturon/lint-conventions-2
Conflicts:
	src/libcollections/slice.rs
	src/libcore/failure.rs
	src/libsyntax/parse/token.rs
	src/test/debuginfo/basic-types-mut-globals.rs
	src/test/debuginfo/simple-struct.rs
	src/test/debuginfo/trait-pointers.rs
2014-10-30 17:37:22 -07:00
Alex Crichton
f3d72dc6a7 rollup merge of #18443 : alexcrichton/deref-vec-and-string 2014-10-30 17:36:49 -07:00
Alex Crichton
1d356624a1 collections: Enable IndexMut for some collections
This commit enables implementations of IndexMut for a number of collections,
including Vec, RingBuf, SmallIntMap, TrieMap, TreeMap, and HashMap. At the same
time this deprecates the `get_mut` methods on vectors in favor of using the
indexing notation.

cc #18424
2014-10-30 08:54:30 -07:00
Alex Crichton
8e9f8f924c collections: impl Deref for Vec/String
This commit adds the following impls:

    impl<T> Deref<[T]> for Vec<T>
    impl<T> DerefMut<[T]> for Vec<T>
    impl Deref<str> for String

This commit also removes all duplicated inherent methods from vectors and
strings as implementations will now silently call through to the slice
implementation. Some breakage occurred at std and beneath due to inherent
methods removed in favor of those in the slice traits and std doesn't use its
own prelude,

cc #18424
2014-10-29 18:48:30 -07:00
Steve Klabnik
7828c3dd28 Rename fail! to panic!
https://github.com/rust-lang/rfcs/pull/221

The current terminology of "task failure" often causes problems when
writing or speaking about code. You often want to talk about the
possibility of an operation that returns a Result "failing", but cannot
because of the ambiguity with task failure. Instead, you have to speak
of "the failing case" or "when the operation does not succeed" or other
circumlocutions.

Likewise, we use a "Failure" header in rustdoc to describe when
operations may fail the task, but it would often be helpful to separate
out a section describing the "Err-producing" case.

We have been steadily moving away from task failure and toward Result as
an error-handling mechanism, so we should optimize our terminology
accordingly: Result-producing functions should be easy to describe.

To update your code, rename any call to `fail!` to `panic!` instead.
Assuming you have not created your own macro named `panic!`, this
will work on UNIX based systems:

    grep -lZR 'fail!' . | xargs -0 -l sed -i -e 's/fail!/panic!/g'

You can of course also do this by hand.

[breaking-change]
2014-10-29 11:43:07 -04:00
bors
98bbccf2c7 auto merge of #18291 : japaric/rust/dstify, r=aturon
This PR changes the signature of several methods from `foo(self, ...)` to `foo(&self, ...)`/`foo(&mut self, ...)`, but there is no breakage of the usage of these methods due to the autoref nature of `method.call()`s. This PR also removes the lifetime parameter from some traits (`Trait<'a>` -> `Trait`). These changes break any use of the extension traits for generic programming, but those traits are not meant to be used for generic programming in the first place. In the whole rust distribution there was only one misuse of a extension trait as a bound, which got corrected (the bound was unnecessary and got removed) as part of this PR.

I've kept the commits as small and self-contained as possible for reviewing sake, but I can squash them when the review is over.

See this [table] to get an idea of what's left to be done. I've already DSTified [`Show`][show] and I'm working on `Hash`, but bootstrapping those changes seem to require a more recent snapshot (#18259 does the trick)

r? @aturon 
cc #16918 

[show]: https://github.com/japaric/rust/commits/show
[table]: https://docs.google.com/spreadsheets/d/1MZ_iSNuzsoqeS-mtLXnj9m0hBYaH5jI8k9G_Ud8FT5g/edit?usp=sharing
2014-10-28 19:56:56 +00:00
Aaron Turon
e0ad0fcb95 Update code with new lint names 2014-10-28 08:54:21 -07:00
bors
9a778bc550 auto merge of #18254 : areski/rust/pr-fix-vec-doc-example, r=alexcrichton
- shrink_to_fit example is now more clear by asserting the capacity value
- annotation [0, mid) changed for [0, mid]
2014-10-28 10:11:51 +00:00
Jorge Aparicio
94ddb51c9c DSTify [T]/str extension traits
This PR changes the signature of several methods from `foo(self, ...)` to
`foo(&self, ...)`/`foo(&mut self, ...)`, but there is no breakage of the usage
of these methods due to the autoref nature of `method.call()`s. This PR also
removes the lifetime parameter from some traits (`Trait<'a>` -> `Trait`). These
changes break any use of the extension traits for generic programming, but
those traits are not meant to be used for generic programming in the first
place. In the whole rust distribution there was only one misuse of a extension
trait as a bound, which got corrected (the bound was unnecessary and got
removed) as part of this PR.

[breaking-change]
2014-10-27 20:20:08 -05:00
Alex Crichton
a33d7617c5 Test fixes and rebase conflicts from rollup 2014-10-27 15:12:48 -07:00
Alex Crichton
175d6a7435 rollup merge of #18332 : jbcrail/fix-comments 2014-10-27 15:12:30 -07:00
areski
a446b68380 Add @thestinger comment explaining that shrink_to_fit might drop down as close as possible but not to the minimun 2014-10-27 22:32:53 +01:00
Joseph Crail
30403204d6 Fix spelling mistakes in comments. 2014-10-25 23:11:17 -04:00
Clark Gaebel
87a5f0ddf4 Make the Vec data structure layout match raw::Slice.
Fixes #18302

r? @thestinger
2014-10-24 20:12:53 -07:00
P1start
ead6c4b9d4 Add a lint for not using field pattern shorthands
Closes #17792.
2014-10-24 15:44:18 +13:00
areski
fe6847a25b Improved examples on Vec documentation
- shrink_to_fit example is now more clear by asserting the capacity value
2014-10-23 16:45:36 +02:00
Alex Crichton
9d5d97b55d Remove a large amount of deprecated functionality
Spring cleaning is here! In the Fall! This commit removes quite a large amount
of deprecated functionality from the standard libraries. I tried to ensure that
only old deprecated functionality was removed.

This is removing lots and lots of deprecated features, so this is a breaking
change. Please consult the deprecation messages of the deleted code to see how
to migrate code forward if it still needs migration.

[breaking-change]
2014-10-19 12:59:40 -07:00
bors
4b064a59cc auto merge of #18096 : Gankro/rust/ganksy-is-dum, r=steveklabnik
Fixes #18010

*phew* that was a lot of work. 😓
2014-10-18 08:27:13 +00:00
bors
93e589c872 auto merge of #18089 : gamazeps/rust/small-bitv-cleanup, r=alexcrichton
I was going to write some doc in order to remove the #[allow(missing_doc)] but there was actually none missing.
I also removed a warning i didn't see in my last commit  #18018
Linked to #18009
2014-10-17 09:22:14 +00:00
Alexis Beingessner
ae8d42937d Fix broken link in libcollections docs
Fixes #18010
2014-10-16 13:26:52 -04:00
Luqman Aden
3ef9aa01af libcollections: Remove all uses of {:?}. 2014-10-16 11:15:35 -04:00
Luqman Aden
38aca17c47 Remove libdebug and update tests. 2014-10-16 11:15:34 -04:00
gamazeps
c1f7a19409 Removes useless confs from bitv.rs
Linked to #18009
2014-10-16 14:41:00 +02:00
bors
b6e0d3a5bf auto merge of #18067 : mahkoh/rust/immutableintslice, r=alexcrichton
There is also a second commit that adds them to the prelude.
2014-10-16 09:12:17 +00:00
bors
8096fee18c auto merge of #17934 : pcwalton/rust/better-autoderef-fixup, r=pnkfelix
librustc: Improve method autoderef/deref/index behavior more, and enable IndexMut on mutable vectors.

This fixes a bug whereby the mutability fixups for method behavior were
not kicking in after autoderef failed to happen at any level. It also
adds support for `Index` to the fixer-upper.

Closes #12825.

r? @pnkfelix
2014-10-15 21:17:22 +00:00
Julian Orth
5c05f900bf export *IntSlice in libcollections 2014-10-15 18:24:32 +02:00
bors
40b2449736 auto merge of #18018 : gamazeps/rust/isuue16736, r=cmr
Closes #16736
linked to #18009
2014-10-14 23:22:20 +00:00
Patrick Walton
f7fb38729e librustc: Improve method autoderef/deref/index behavior more, and enable
`IndexMut` on mutable vectors.

This fixes a bug whereby the mutability fixups for method behavior were
not kicking in after autoderef failed to happen at any level. It also
adds support for `Index` to the fixer-upper.

Closes #12825.
2014-10-14 14:44:17 -07:00
Felix Raimundo
1ef5e388b9 Switches from uint to u32 in BitV and BitVSet
Closes #16736
linked to #18009
2014-10-14 13:50:50 +02:00
Alex Crichton
986d62e239 rollup merge of #17970 : nodakai/cleanup-warnings 2014-10-13 15:09:38 -07:00
Alex Crichton
e9f241bc5d rollup merge of #17888 : gmfawcett/patch-1 2014-10-13 15:09:14 -07:00
NODA, Kai
f27ad3d3e9 Clean up rustc warnings.
compiletest: compact "linux" "macos" etc.as "unix".
liballoc: remove a superfluous "use".
libcollections: remove invocations of deprecated methods in favor of
    their suggested replacements and use "_" for a loop counter.
libcoretest: remove invocations of deprecated methods;  also add
    "allow(deprecated)" for testing a deprecated method itself.
libglob: use "cfg_attr".
libgraphviz: add a test for one of data constructors.
libgreen: remove a superfluous "use".
libnum: "allow(type_overflow)" for type cast into u8 in a test code.
librustc: names of static variables should be in upper case.
libserialize: v[i] instead of get().
libstd/ascii: to_lowercase() instead of to_lower().
libstd/bitflags: modify AnotherSetOfFlags to use i8 as its backend.
    It will serve better for testing various aspects of bitflags!.
libstd/collections: "allow(deprecated)" for testing a deprecated
    method itself.
libstd/io: remove invocations of deprecated methods and superfluous "use".
    Also add #[test] where it was missing.
libstd/num: introduce a helper function to effectively remove
    invocations of a deprecated method.
libstd/path and rand: remove invocations of deprecated methods and
    superfluous "use".
libstd/task and libsync/comm: "allow(deprecated)" for testing
    a deprecated method itself.
libsync/deque: remove superfluous "unsafe".
libsync/mutex and once: names of static variables should be in upper case.
libterm: introduce a helper function to effectively remove
    invocations of a deprecated method.

We still see a few warnings about using obsoleted native::task::spawn()
in the test modules for libsync.  I'm not sure how I should replace them
with std::task::TaksBuilder and native::task::NativeTaskBuilder
(dependency to libstd?)

Signed-off-by: NODA, Kai <nodakai@gmail.com>
2014-10-13 14:16:22 +08:00
bors
adb44f53d8 auto merge of #17942 : JIghtuse/rust/master, r=alexcrichton
[breaking-change]
Closes #17916
2014-10-12 00:07:15 +00:00
bors
cd1fa91d2b auto merge of #17801 : Gankro/rust/collections-stuff, r=sfackler
I previously avoided `#[inline]`ing anything assuming someone would come in and explain to me where this would be appropriate. Apparently no one *really* knows, so I'll just go the opposite way an inline everything assuming someone will come in and yell at me that such-and-such shouldn't be `#[inline]`.

==================

For posterity, iteration comparisons:

```
test btree::map::bench::iter_20                            ... bench:       971 ns/iter (+/- 30)
test btree::map::bench::iter_1000                          ... bench:     29445 ns/iter (+/- 480)
test btree::map::bench::iter_100000                        ... bench:   2929035 ns/iter (+/- 21551)

test treemap::bench::iter_20                               ... bench:       530 ns/iter (+/- 66)
test treemap::bench::iter_1000                             ... bench:     26287 ns/iter (+/- 825)
test treemap::bench::iter_100000                           ... bench:   7650084 ns/iter (+/- 356711)

test trie::bench_map::iter_20                              ... bench:       646 ns/iter (+/- 265)
test trie::bench_map::iter_1000                            ... bench:     43556 ns/iter (+/- 5014)
test trie::bench_map::iter_100000                          ... bench:  12988002 ns/iter (+/- 139676)
```

As you can see `btree` "scales" much better than `treemap`. `triemap` scales quite poorly.

Note that *completely* different results are given if the elements are inserted in order from the range [0, size]. In particular, TrieMap *completely* dominates in the sorted case. This suggests adding benches for both might be worthwhile. However unsorted is *probably* the more "normal" case, so I consider this "good enough" for now.
2014-10-11 18:37:13 +00:00
Boris Egorov
6e29f86bc8 Remove into_vec method from &[T]
[breaking-change]
Closes #17916
2014-10-11 16:22:43 +07:00
Alex Crichton
dae48a07f3 Register new snapshots
Also convert a number of `static mut` to just a plain old `static` and remove
some unsafe blocks.
2014-10-10 22:09:49 -07:00
Daniel Micay
02d976a7f9 improve the performance of the vec![] macro
Closes #17865
2014-10-10 14:20:12 -04:00
Daniel Micay
310f2deb99 implement Box<[T]> <-> Vec<T> conversions 2014-10-10 11:42:30 -04:00
Daniel Micay
0075c27626 vec: minor cleanup 2014-10-10 06:21:00 -04:00
bors
f9fc49c06e auto merge of #17853 : alexcrichton/rust/issue-17718, r=pcwalton
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.

The semantics of these three kinds of globals are:

* A `const` does not represent a memory location, but only a value. Constants
  are translated as rvalues, which means that their values are directly inlined
  at usage location (similar to a #define in C/C++). Constant values are, well,
  constant, and can not be modified. Any "modification" is actually a
  modification to a local value on the stack rather than the actual constant
  itself.

  Almost all values are allowed inside constants, whether they have interior
  mutability or not. There are a few minor restrictions listed in the RFC, but
  they should in general not come up too often.

* A `static` now always represents a memory location (unconditionally). Any
  references to the same `static` are actually a reference to the same memory
  location. Only values whose types ascribe to `Sync` are allowed in a `static`.
  This restriction is in place because many threads may access a `static`
  concurrently. Lifting this restriction (and allowing unsafe access) is a
  future extension not implemented at this time.

* A `static mut` continues to always represent a memory location. All references
  to a `static mut` continue to be `unsafe`.

This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:

* Statics may no longer be used in patterns. Statics now always represent a
  memory location, which can sometimes be modified. To fix code, repurpose the
  matched-on-`static` to a `const`.

      static FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

  change this code to:

      const FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

* Statics may no longer refer to other statics by value. Due to statics being
  able to change at runtime, allowing them to reference one another could
  possibly lead to confusing semantics. If you are in this situation, use a
  constant initializer instead. Note, however, that statics may reference other
  statics by address, however.

* Statics may no longer be used in constant expressions, such as array lengths.
  This is due to the same restrictions as listed above. Use a `const` instead.

[breaking-change]
Closes #17718 

[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-10 00:07:08 +00:00
bors
8b12fb326b auto merge of #17891 : brson/rust/verbump, r=alexcrichton 2014-10-09 21:12:03 +00:00
bors
79d056f94b auto merge of #17558 : kaseyc/rust/fix_bitvset_union, r=aturon
Updates the other_op function shared by the union/intersect/difference/symmetric_difference -with functions to fix an issue where certain elements would not be present in the result. To fix this, when other op is called, we resize self's nbits to account for any new elements that may be added to the set.

Example:
```rust
	let mut a = BitvSet::new();
	let mut b = BitvSet::new();
	a.insert(0);
	b.insert(5);
	a.union_with(&b);
	println!("{}", a); //Prints "{0}" instead of "{0, 5}"
```
2014-10-09 19:02:06 +00:00
Brian Anderson
5c92a8e054 Use the same html_root_url for all docs 2014-10-09 10:50:13 -07:00
Brian Anderson
6beddcfd83 Revert "Update html_root_url for 0.12.0 release"
This reverts commit 2288f33230.
2014-10-09 10:34:34 -07:00
Alex Crichton
abb3d3e444 collections: Convert statics to constants 2014-10-09 09:44:51 -07:00
Brian Anderson
158eaa643b 0.12.0 release
-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJUNrj+AAoJEIWrlub6G+X+4TMQAIlyIoTpbZfA7MgaqHmrqp/O
 DkWH4sjoiTL3pdqHitbaJWFzStLjmM+hzOKYVYxXJGqpHuZv7pbnN2sQCKvJ6m9E
 htojoy9ZVeOUjkqz3+PYc6mh+SuQq4bpAhnnt60tLSxZCda7uTpdTcsOgDlwhu8P
 /YIbnBHo6brcQi6kEK27uN7U2MsluRR/ZhAmZH1mvrTtjKrGsKTEdta2NW1tUzNT
 sDluM9D0/WFjwSA9OohjtpUI7KYudqChOCRaqREgNq6xc/9at/TQHULsjzxLFIiC
 tAttF7ZZ2s1TmS4qzmx3AAWl8n8xYrDo+CpfPqKvSGwDegfHN9Epa+24Cdf2Q5GO
 9RSup89NlNNo3tjmK+G1cUqi/K9RseiZNPSJSoLlR2L9QFg/VFEVbcaZX+oX+CQF
 pfWkKqsfLqj50EimO+vuXRZhShHlu/McOdN0cd+S0KEGdd7ngqU3d7YJf9Ppm1mV
 d1VUqnPxvDrGQTGqk4cpGMIv+LmT6vY2iix3ha583zMYcU9VWrC9VEmR3I4XZefE
 UgsbAx2jIgagWa6ylDpes7X8dn/7qj3BA6l3Bt9aGrs9KnyQ+a3xOyz8dFvRJwks
 T8izOhfJXpxW4CLFZjDIQ9RD/joJuvuqTSIqf7zGIxIbMUQFB9EC/Rn7a3ftidds
 aZVZSl2li1vOa3DucW64
 =4lHl
 -----END PGP SIGNATURE-----

Merge tag '0.12.0'

0.12.0 release
2014-10-09 09:36:30 -07:00
Graham Fawcett
7cf1f55426 In sieve example, end iteration sooner
The Sieve algorithm only requires checking all elements up to and including the square root of the maximum prime you're looking for. After that, the remaining elements are guaranteed to be prime.
2014-10-09 10:02:07 -04:00
bors
e6cfb56a5c auto merge of #17870 : thestinger/rust/alloc, r=eddyb
Using reallocate(old_ptr, old_size, new_size, align) makes a lot more
sense than reallocate(old_ptr, new_size, align, old_size) and matches up
with the order used by existing platform APIs like mremap.

Closes #17837

[breaking-change]
2014-10-09 10:57:25 +00:00
Kasey Carrothers
dd4fa906fc Clean up the implementations of Bitv and BitvSet.
Functions that add bits now ensure that any unused bits are set to 0.
`into_bitv` sanitizes the nbits of the Bitv/BitvSet it returns by setting the nbits to the current capacity.
Fix a bug with `union_with` and `symmetric_difference` with due to not updating nbits properly
Add test cases to the _with functions
Remove `get_mut_ref`

This is a [breaking-change]. The things you will need to fix are:

1. BitvSet's `unwrap()` has been renamed to `into_bitv`
2. BitvSet's `get_mut_ref()` has been removed. Use `into_bitv()` and `from_bitv()` instead.
2014-10-08 18:35:29 -07:00
Daniel Micay
1c6fd76f80 saner parameter order for reallocation functions
Using reallocate(old_ptr, old_size, new_size, align) makes a lot more
sense than reallocate(old_ptr, new_size, align, old_size) and matches up
with the order used by existing platform APIs like mremap.

Closes #17837

[breaking-change]
2014-10-08 12:46:09 -04:00
bors
bc649ba8f8 auto merge of #17447 : thestinger/rust/silly_string, r=aturon
This provides a way to pass `&[T]` to functions taking `&U` where `U` is
a `Vec<T>`. This is useful in many cases not covered by the Equiv trait
or methods like `find_with` on TreeMap.
2014-10-08 08:27:10 +00:00
Daniel Micay
f744479562 add #[experimental] as_string/as_vec functions
This provides a way to pass `&[T]` to functions taking `&U` where `U` is
a `Vec<T>`. This is useful in many cases not covered by the Equiv trait
or methods like `find_with` on TreeMap.
2014-10-08 04:18:54 -04:00
bors
57af34b9ad auto merge of #17840 : Sawyer47/rust/issue-17751, r=huonw
Closes #17751
2014-10-08 05:32:09 +00:00
Brian Anderson
2288f33230 Update html_root_url for 0.12.0 release 2014-10-07 11:18:50 -07:00
bors
a3786db706 auto merge of #17802 : Gankro/rust/collection-docs-redux, r=aturon
Adds a high-level discussion of "what collection should you use for what", as well as some general discussion of correct/efficient usage of the capacity, iterator, and entry APIs.

Still building docs to confirm this renders right and the examples are good, but the content can be reviewed now.
2014-10-07 09:42:06 +00:00
Piotr Jawniak
e8c03c3f42 Re-exports core::str::Utf16CodeUnits in std::str
Closes #17751
2014-10-07 08:51:12 +02:00
Alexis Beingessner
1d6eda30c6 add missing btree re-exports 2014-10-06 23:19:15 -04:00
Alexis Beingessner
8f4e855009 library-level docs for collections 2014-10-06 23:19:14 -04:00
Nick Cameron
3b0550c3a9 Rename slicing methods 2014-10-07 15:49:53 +13:00
Nick Cameron
cd21e4a72c Rename slice::Slice 2014-10-07 15:49:53 +13:00
Nick Cameron
2d3823441f Put slicing syntax behind a feature gate.
[breaking-change]

If you are using slicing syntax you will need to add #![feature(slicing_syntax)] to your crate.
2014-10-07 15:49:53 +13:00
Nick Cameron
59976942ea Use slice syntax instead of slice_to, etc. 2014-10-07 15:49:53 +13:00
Alexis Beingessner
f91c680e95 doc fixups 2014-10-06 20:12:58 -04:00
Alexis Beingessner
7c04b3c5bd flesh out BTree docs 2014-10-05 19:58:56 -04:00
Alexis Beingessner
79c21d9e79 adding iterator benches to tree-based maps for comparison purposes 2014-10-05 13:35:16 -04:00
Simon Sapin
80401da12e String::truncate doc: also fails if not a char boundary 2014-10-05 12:15:59 +01:00
bors
a2e7c4da9b auto merge of #17738 : hoeppnertill/rust/master, r=alexcrichton
There is an issue with lev_distance, where
```
fn main() {
    println!("{}", "\x80".lev_distance("\x80"))
}
```
prints `2`.

This is due to using the byte length instead of the char length.
2014-10-04 19:32:07 +00:00
Simon Sapin
80eb616bd3 Fix preallocation amount in String::from_utf16
`v.len()` counts code units, not UTF-16 bytes. The lower bound is one UTF-8 byte per code unit, not per two code units.
2014-10-03 21:20:04 +01:00
Till Hoeppner
3aea7f1889 Fix lev_distance 2014-10-03 16:46:30 +02:00
Alex Crichton
7ae802f57b rollup merge of #17666 : eddyb/take-garbage-out
Conflicts:
	src/libcollections/lib.rs
	src/libcore/lib.rs
	src/librustdoc/lib.rs
	src/librustrt/lib.rs
	src/libserialize/lib.rs
	src/libstd/lib.rs
	src/test/run-pass/issue-8898.rs
2014-10-02 14:53:18 -07:00
Alex Crichton
8bb5a674a4 rollup merge of #16993 : dschatzberg/items-bounds 2014-10-02 14:49:42 -07:00
Aaron Turon
d2ea0315e0 Revert "Use slice syntax instead of slice_to, etc."
This reverts commit 40b9f5ded5.
2014-10-02 11:48:07 -07:00
Aaron Turon
c0c6c89589 Revert "Remove the _ suffix from slice methods."
This reverts commit df2f1fa768.
2014-10-02 11:47:58 -07:00
Aaron Turon
7bf56df4c8 Revert "Put slicing syntax behind a feature gate."
This reverts commit 95cfc35607.
2014-10-02 11:47:51 -07:00
Aaron Turon
2f365ffdad Revert "Review and rebasing changes"
This reverts commit 6e0611a487.
2014-10-02 11:47:38 -07:00
Dan Schatzberg
49e593c3d6 Add fixes for new lifetime bounds 2014-10-02 14:06:31 -04:00
Dan Schatzberg
0c63a4a4f5 Add tests for MoveItems 2014-10-02 11:23:06 -04:00
Dan Schatzberg
f14cb96b07 Use RawPtr::offset when size_of::<T>() > 0 2014-10-02 11:22:05 -04:00
Dan Schatzberg
4184396f28 Add lifetime bounds on Items and MutItems.
This also requires a fix for Vec's MoveItems. This resolves issue #16941
2014-10-02 11:22:05 -04:00
Eduard Burtescu
58bea31ca0 tests: remove uses of Gc. 2014-10-02 17:02:15 +03:00
Eduard Burtescu
db55e70c97 syntax: mark the managed_boxes feature as Removed. 2014-10-02 17:02:03 +03:00
bors
07b2c1be9d auto merge of #17620 : nick29581/rust/slice4, r=aturon
cc @aturon 

r? anyone?
2014-10-02 03:07:17 +00:00
Nick Cameron
6e0611a487 Review and rebasing changes 2014-10-02 14:50:22 +13:00
bors
d53874eccf auto merge of #17381 : tbu-/rust/pr_mapinplace2, r=aturon
Additionally, support zero-sized types.

Now there isn't a safe interface of `PartialVec` anymore, it's just a bare data structure with destructor that assumes you handled everything correctly before.
2014-10-02 01:22:20 +00:00
Nick Cameron
95cfc35607 Put slicing syntax behind a feature gate.
[breaking-change]

If you are using slicing syntax you will need to add #![feature(slicing_syntax)] to your crate.
2014-10-02 13:23:36 +13:00
Nick Cameron
df2f1fa768 Remove the _ suffix from slice methods.
Deprecates slicing methods from ImmutableSlice/MutableSlice in favour of slicing syntax or the methods in Slice/SliceMut.

Closes #17273.
2014-10-02 13:19:45 +13:00
Nick Cameron
40b9f5ded5 Use slice syntax instead of slice_to, etc. 2014-10-02 13:19:45 +13:00
Patrick Walton
416144b827 librustc: Forbid .. in range patterns.
This breaks code that looks like:

    match foo {
        1..3 => { ... }
    }

Instead, write:

    match foo {
        1...3 => { ... }
    }

Closes #17295.

[breaking-change]
2014-09-30 09:11:26 -07:00
Alex Crichton
1ae44c2059 rollup merge of #17621 : sfackler/new-snap 2014-09-29 08:17:18 -07:00
Alex Crichton
86b1e6fd8c rollup merge of #17599 : Gankro/enum-ord 2014-09-29 08:14:29 -07:00
Alex Crichton
735d16b1b0 rollup merge of #17585 : sfackler/string-slice 2014-09-29 08:14:16 -07:00
Alex Crichton
55754ed893 rollup merge of #17577 : squeaky-pl/patch-1 2014-09-29 08:12:54 -07:00
Steven Fackler
fa419d3d21 Register new snapshots 2014-09-28 19:28:48 -07:00
Alexis Beingessner
e27308b31b make EnumSet derive Ord and PartialOrd 2014-09-27 16:47:53 -04:00
bors
ef112fe185 auto merge of #17334 : Gankro/rust/btree-vec, r=huonw
Replaces BTree with BTreeMap and BTreeSet, which are completely new implementations.
BTreeMap's internal Node representation is particularly inefficient at the moment to
make this first implementation easy to reason about and fairly safe. Both collections
are also currently missing some of the tooling specific to sorted collections, which
is planned as future work pending reform of these APIs. General implementation issues
are discussed with TODOs internally

[breaking-change]

Still waiting on compilation/test/bench stuff locally, but the edit-distance on any errors should be very small at this point. This is ready to be reviewed.
2014-09-27 16:17:50 +00:00
Alexis Beingessner
b6edc59413 complete btree rewrite
Replaces BTree with BTreeMap and BTreeSet, which are completely new implementations.
BTreeMap's internal Node representation is particularly inefficient at the moment to
make this first implementation easy to reason about and fairly safe. Both collections
are also currently missing some of the tooling specific to sorted collections, which
is planned as future work pending reform of these APIs. General implementation issues
are discussed with TODOs internally

Perf results on x86_64 Linux:

test treemap::bench::find_rand_100                         ... bench:        76 ns/iter (+/- 4)
test treemap::bench::find_rand_10_000                      ... bench:       163 ns/iter (+/- 6)
test treemap::bench::find_seq_100                          ... bench:        77 ns/iter (+/- 3)
test treemap::bench::find_seq_10_000                       ... bench:       115 ns/iter (+/- 1)
test treemap::bench::insert_rand_100                       ... bench:       111 ns/iter (+/- 1)
test treemap::bench::insert_rand_10_000                    ... bench:       996 ns/iter (+/- 18)
test treemap::bench::insert_seq_100                        ... bench:       486 ns/iter (+/- 20)
test treemap::bench::insert_seq_10_000                     ... bench:       800 ns/iter (+/- 15)

test btree::map::bench::find_rand_100                      ... bench:        74 ns/iter (+/- 4)
test btree::map::bench::find_rand_10_000                   ... bench:       153 ns/iter (+/- 5)
test btree::map::bench::find_seq_100                       ... bench:        82 ns/iter (+/- 1)
test btree::map::bench::find_seq_10_000                    ... bench:       108 ns/iter (+/- 0)
test btree::map::bench::insert_rand_100                    ... bench:       220 ns/iter (+/- 1)
test btree::map::bench::insert_rand_10_000                 ... bench:       620 ns/iter (+/- 16)
test btree::map::bench::insert_seq_100                     ... bench:       411 ns/iter (+/- 12)
test btree::map::bench::insert_seq_10_000                  ... bench:       534 ns/iter (+/- 14)

BTreeMap still has a lot of room for optimization, but it's already beating out TreeMap on most access patterns.

[breaking-change]
2014-09-27 10:25:46 -04:00
Steven Fackler
aa2814fd4e Implement Slice for String and str
Closes #17502
2014-09-26 21:48:49 -07:00
Squeaky
070ba14a71 Correct stability marker in string.rs 2014-09-27 02:37:28 +02:00
Aaron Turon
c59ef666a5 Add tests for new _mut variants 2014-09-25 17:46:03 -07:00
bors
5366cfecf3 auto merge of #17438 : alexcrichton/rust/string-stable, r=aturon
# Rationale

When dealing with strings, many functions deal with either a `char` (unicode
codepoint) or a byte (utf-8 encoding related). There is often an inconsistent
way in which methods are referred to as to whether they contain "byte", "char",
or nothing in their name.  There are also issues open to rename *all* methods to
reflect that they operate on utf8 encodings or bytes (e.g. utf8_len() or
byte_len()).

The current state of String seems to largely be what is desired, so this PR
proposes the following rationale for methods dealing with bytes or characters:

> When constructing a string, the input encoding *must* be mentioned (e.g.
> from_utf8). This makes it clear what exactly the input type is expected to be
> in terms of encoding.
>
> When a method operates on anything related to an *index* within the string
> such as length, capacity, position, etc, the method *implicitly* operates on
> bytes. It is an understood fact that String is a utf-8 encoded string, and
> burdening all methods with "bytes" would be redundant.
>
> When a method operates on the *contents* of a string, such as push() or pop(),
> then "char" is the default type. A String can loosely be thought of as being a
> collection of unicode codepoints, but not all collection-related operations
> make sense because some can be woefully inefficient.

# Method stabilization

The following methods have been marked #[stable]

* The String type itself
* String::new
* String::with_capacity
* String::from_utf16_lossy
* String::into_bytes
* String::as_bytes
* String::len
* String::clear
* String::as_slice

The following methods have been marked #[unstable]

* String::from_utf8 - The error type in the returned `Result` may change to
                      provide a nicer message when it's `unwrap()`'d
* String::from_utf8_lossy - The returned `MaybeOwned` type still needs
                            stabilization
* String::from_utf16 - The return type may change to become a `Result` which
                       includes more contextual information like where the error
                       occurred.
* String::from_chars - This is equivalent to iter().collect(), but currently not
                       as ergonomic.
* String::from_char - This method is the equivalent of Vec::from_elem, and has
                      been marked #[unstable] becuase it can be seen as a
                      duplicate of iterator-based functionality as well as
                      possibly being renamed.
* String::push_str - This *can* be emulated with .extend(foo.chars()), but is
                     less efficient because of decoding/encoding. Due to the
                     desire to minimize API surface this may be able to be
                     removed in the future for something possibly generic with
                     no loss in performance.
* String::grow - This is a duplicate of iterator-based functionality, which may
                 become more ergonomic in the future.
* String::capacity - This function was just added.
* String::push - This function was just added.
* String::pop - This function was just added.
* String::truncate - The failure conventions around String methods and byte
                     indices isn't totally clear at this time, so the failure
                     semantics and return value of this method are subject to
                     change.
* String::as_mut_vec - the naming of this method may change.
* string::raw::* - these functions are all waiting on [an RFC][2]

[2]: rust-lang/rfcs#240

The following method have been marked #[experimental]

* String::from_str - This function only exists as it's more efficient than
                     to_string(), but having a less ergonomic function for
                     performance reasons isn't the greatest reason to keep it
                     around. Like Vec::push_all, this has been marked
                     experimental for now.

The following methods have been #[deprecated]

* String::append - This method has been deprecated to remain consistent with the
                   deprecation of Vec::append. While convenient, it is one of
                   the only functional-style apis on String, and requires more
                   though as to whether it belongs as a first-class method or
                   now (and how it relates to other collections).
* String::from_byte - This is fairly rare functionality and can be emulated with
                      str::from_utf8 plus an assert plus a call to to_string().
                      Additionally, String::from_char could possibly be used.
* String::byte_capacity - Renamed to String::capacity due to the rationale
                          above.
* String::push_char - Renamed to String::push due to the rationale above.
* String::pop_char - Renamed to String::pop due to the rationale above.
* String::push_bytes - There are a number of `unsafe` functions on the `String`
                       type which allow bypassing utf-8 checks. These have all
                       been deprecated in favor of calling `.as_mut_vec()` and
                       then operating directly on the vector returned. These
                       methods were deprecated because naming them with relation
                       to other methods was difficult to rationalize and it's
                       arguably more composable to call .as_mut_vec().
* String::as_mut_bytes - See push_bytes
* String::push_byte - See push_bytes
* String::pop_byte - See push_bytes
* String::shift_byte - See push_bytes

# Reservation methods

This commit does not yet touch the methods for reserving bytes. The methods on
Vec have also not yet been modified. These methods are discussed in the upcoming
[Collections reform RFC][1]

[1]: https://github.com/aturon/rfcs/blob/collections-conventions/active/0000-collections-conventions.md#implicit-growth
2014-09-24 14:00:57 +00:00
Alex Crichton
50375139e2 Deal with the fallout of string stabilization 2014-09-23 18:31:52 -07:00
Victor Berger
d845857fd9 Fix deprecation warnings in check-docs.
Fallout of closing #17185.
2014-09-22 19:31:31 +02:00
Victor Berger
52ea83dddc Update calls of deprecated functions in macros.
Fallout of #17185.
2014-09-22 19:30:06 +02:00
Alex Crichton
31be3319bf collections: Deprecate shift_char for insert/remove
This commit deprecates the String::shift_char() function in favor of the
addition of an insert()/remove() pair of functions. This aligns the API with Vec
in that characters can be inserted at arbitrary positions.  Additionaly, there
is no `_char` suffix due to the rationaled laid out in the previous commit.

These functions are both introduced as unstable as their failure semantics,
while in line with slices/vectors, are uncertain about whether they should
remain the same.
2014-09-22 08:24:14 -07:00
Alex Crichton
79b4ce06ae collections: Stabilize String
# Rationale

When dealing with strings, many functions deal with either a `char` (unicode
codepoint) or a byte (utf-8 encoding related). There is often an inconsistent
way in which methods are referred to as to whether they contain "byte", "char",
or nothing in their name.  There are also issues open to rename *all* methods to
reflect that they operate on utf8 encodings or bytes (e.g. utf8_len() or
byte_len()).

The current state of String seems to largely be what is desired, so this PR
proposes the following rationale for methods dealing with bytes or characters:

> When constructing a string, the input encoding *must* be mentioned (e.g.
> from_utf8). This makes it clear what exactly the input type is expected to be
> in terms of encoding.
>
> When a method operates on anything related to an *index* within the string
> such as length, capacity, position, etc, the method *implicitly* operates on
> bytes. It is an understood fact that String is a utf-8 encoded string, and
> burdening all methods with "bytes" would be redundant.
>
> When a method operates on the *contents* of a string, such as push() or pop(),
> then "char" is the default type. A String can loosely be thought of as being a
> collection of unicode codepoints, but not all collection-related operations
> make sense because some can be woefully inefficient.

# Method stabilization

The following methods have been marked #[stable]

* The String type itself
* String::new
* String::with_capacity
* String::from_utf16_lossy
* String::into_bytes
* String::as_bytes
* String::len
* String::clear
* String::as_slice

The following methods have been marked #[unstable]

* String::from_utf8 - The error type in the returned `Result` may change to
                      provide a nicer message when it's `unwrap()`'d
* String::from_utf8_lossy - The returned `MaybeOwned` type still needs
                            stabilization
* String::from_utf16 - The return type may change to become a `Result` which
                       includes more contextual information like where the error
                       occurred.
* String::from_chars - This is equivalent to iter().collect(), but currently not
                       as ergonomic.
* String::from_char - This method is the equivalent of Vec::from_elem, and has
                      been marked #[unstable] becuase it can be seen as a
                      duplicate of iterator-based functionality as well as
                      possibly being renamed.
* String::push_str - This *can* be emulated with .extend(foo.chars()), but is
                     less efficient because of decoding/encoding. Due to the
                     desire to minimize API surface this may be able to be
                     removed in the future for something possibly generic with
                     no loss in performance.
* String::grow - This is a duplicate of iterator-based functionality, which may
                 become more ergonomic in the future.
* String::capacity - This function was just added.
* String::push - This function was just added.
* String::pop - This function was just added.
* String::truncate - The failure conventions around String methods and byte
                     indices isn't totally clear at this time, so the failure
                     semantics and return value of this method are subject to
                     change.
* String::as_mut_vec - the naming of this method may change.
* string::raw::* - these functions are all waiting on [an RFC][2]

[2]: https://github.com/rust-lang/rfcs/pull/240

The following method have been marked #[experimental]

* String::from_str - This function only exists as it's more efficient than
                     to_string(), but having a less ergonomic function for
                     performance reasons isn't the greatest reason to keep it
                     around. Like Vec::push_all, this has been marked
                     experimental for now.

The following methods have been #[deprecated]

* String::append - This method has been deprecated to remain consistent with the
                   deprecation of Vec::append. While convenient, it is one of
                   the only functional-style apis on String, and requires more
                   though as to whether it belongs as a first-class method or
                   now (and how it relates to other collections).
* String::from_byte - This is fairly rare functionality and can be emulated with
                      str::from_utf8 plus an assert plus a call to to_string().
                      Additionally, String::from_char could possibly be used.
* String::byte_capacity - Renamed to String::capacity due to the rationale
                          above.
* String::push_char - Renamed to String::push due to the rationale above.
* String::pop_char - Renamed to String::pop due to the rationale above.
* String::push_bytes - There are a number of `unsafe` functions on the `String`
                       type which allow bypassing utf-8 checks. These have all
                       been deprecated in favor of calling `.as_mut_vec()` and
                       then operating directly on the vector returned. These
                       methods were deprecated because naming them with relation
                       to other methods was difficult to rationalize and it's
                       arguably more composable to call .as_mut_vec().
* String::as_mut_bytes - See push_bytes
* String::push_byte - See push_bytes
* String::pop_byte - See push_bytes
* String::shift_byte - See push_bytes

# Reservation methods

This commit does not yet touch the methods for reserving bytes. The methods on
Vec have also not yet been modified. These methods are discussed in the upcoming
[Collections reform RFC][1]

[1]: https://github.com/aturon/rfcs/blob/collections-conventions/active/0000-collections-conventions.md#implicit-growth
2014-09-22 07:46:40 -07:00
Alex Crichton
0169218047 Fix fallout from Vec stabilization 2014-09-21 22:15:51 -07:00
Alex Crichton
087b9283a0 collections: Stabilize Vec
The following methods, types, and names have become stable:

* Vec
* Vec::as_mut_slice
* Vec::as_slice
* Vec::capacity
* Vec::clear
* Vec::default
* Vec::grow
* Vec::insert
* Vec::len
* Vec::new
* Vec::pop
* Vec::push
* Vec::remove
* Vec::set_len
* Vec::shrink_to_fit
* Vec::truncate
* Vec::with_capacity

The following have become unstable:

* Vec::dedup        // naming
* Vec::from_fn      // naming and unboxed closures
* Vec::get_mut      // will be removed for IndexMut
* Vec::grow_fn      // unboxed closures and naming
* Vec::retain       // unboxed closures
* Vec::swap_remove  // uncertain naming
* Vec::from_elem    // uncertain semantics
* vec::unzip        // should be generic for all collections

The following have been deprecated

* Vec::append - call .extend()
* Vec::append_one - call .push()
* Vec::from_slice - call .to_vec()
* Vec::grow_set - call .grow() and then .push()
* Vec::into_vec - move the vector instead
* Vec::move_iter - renamed to iter_move()
* Vec::to_vec - call .clone()

The following methods remain experimental pending conventions

* vec::raw
* vec::raw::from_buf
* Vec:from_raw_parts
* Vec::push_all

This is a breaking change in terms of the signature of the `Vec::grow` function.
The argument used to be taken by reference, but it is now taken by value. Code
must update by removing a leading `&` sigil or by calling `.clone()` to create a
value.

[breaking-change]
2014-09-21 21:05:05 -07:00
Alex Crichton
04f5fe5a08 rollup merge of #17338 : nick29581/variants-namespace 2014-09-19 10:00:29 -07:00
Nick Cameron
ce0907e46e Add enum variants to the type namespace
Change to resolve and update compiler and libs for uses.

[breaking-change]

Enum variants are now in both the value and type namespaces. This means that
if you have a variant with the same name as a type in scope in a module, you
will get a name clash and thus an error. The solution is to either rename the
type or the variant.
2014-09-19 15:11:00 +12:00
Tobias Bucher
454d91d3d2 Refactor Vec::map_in_place to move code out of PartialVec
Additionally, support zero-sized types.
2014-09-19 01:38:50 +02:00
Nick Cameron
31a7e38759 Implement slicing syntax.
`expr[]`, `expr[expr..]`, `expr[..expr]`,`expr[expr..expr]`

Uses the Slice and SliceMut traits.

Allows ... as well as .. in range patterns.
2014-09-19 11:15:49 +12:00
Aaron Turon
fc525eeb4e Fallout from renaming 2014-09-16 14:37:48 -07:00
Aaron Turon
d8dfe1957b Align with _mut conventions
As per [RFC
52](https://github.com/rust-lang/rfcs/blob/master/active/0052-ownership-variants.md),
use `_mut` suffixes to mark mutable variants, and `into_iter` for moving
iterators.

[breaking-change]
2014-09-16 11:46:52 -07:00
bors
828e075abd auto merge of #17266 : Gankro/rust/vec-move, r=alexcrichton
Seems to correctly report exact size, so it should claim to do so formally.
2014-09-16 17:06:00 +00:00
bors
cdd46f8592 auto merge of #17245 : sfackler/rust/enumset-show, r=alexcrichton 2014-09-16 13:41:00 +00:00
bors
3212d70302 auto merge of #17280 : thestinger/rust/heap, r=pcwalton 2014-09-16 04:56:01 +00:00
Daniel Micay
84b37374bf heap: optimize EMPTY to avoid relocations
Sized deallocation makes it pointless to provide an address that never
overlaps with pointers returned by an allocator. Code can branch on the
capacity of the allocation instead of a comparison with this sentinel.

This improves the situation in #8859, and the remaining issues are only
from the logging API, which should be disabled by default in optimized
release builds anyway along with debug assertions. The remaining issues
are part of #17081.

Closes #8859
2014-09-15 16:48:20 -04:00
bors
8e2860407b auto merge of #16887 : steveklabnik/rust/guide_iterators, r=alexcrichton
This isn't ready to merge yet.

The 'containers and iterators' guide is basically just a collection of stuff that should be in the module definitions. So I'm moving the guide to just an 'iterators' guide, and moved the info that was there into the right places.

So, is this a good path forward, and is all of the information still correct?
2014-09-15 15:11:12 +00:00
Alexis Beingessner
975569b380 impl ExactSize for vec::MoveItems 2014-09-14 23:25:08 -04:00
Tobias Bucher
2c7f6eee0c Fixed map_in_place tests after rustc upgrade
This replaces the now obsolete syntax `&[]` with `[].as_slice()`.
2014-09-14 21:35:49 +02:00
Tobias Bucher
7ccab3ae8a Added missing } from map_in_place rebase 2014-09-14 21:35:49 +02:00
Tobias Bucher
79427f0bc0 Remove the unused Iterator implementation of the private PartialVec 2014-09-14 21:35:49 +02:00
Tobias Bucher
b7e0969a49 Minimize the public interface and rename it to map_in_place 2014-09-14 21:35:48 +02:00
Tobias Bucher
5efa232160 Check that the min_align_of the both types in a PartialVec matches
This is important because the underlying allocator of the `Vec` passes that
information to the deallocator which needs the guarantee that it is the same
parameters that were also passed to the allocation function.
2014-09-14 21:35:48 +02:00
Tobias Bucher
23f2c78d21 Fix some of the issues mentioned in the PR on Github
This specifically includes:
- Fix of the tests
- Remove `transmute` between `Vec`s of different types
2014-09-14 21:35:48 +02:00
Tobias Bucher
af293372e4 PartialVec: Remove TODOs and rename unwrap to into_vec 2014-09-14 21:35:48 +02:00
Tobias Bucher
dbc3cb3a54 Add support for in-place map for Vecs of types with same size
This is implemented using a new struct `PartialVec` which implements the proper
drop semantics in case the conversion is interrupted by an unwind.
2014-09-14 21:35:48 +02:00
Steven Fackler
0e8cc52311 Properly implement Show for EnumSet 2014-09-13 17:37:03 -07:00
Steve Klabnik
84030fd05a Move info into individual modules. 2014-09-13 15:05:56 -04:00
Jonas Hietala
947a1b923b Remove some test warnings. 2014-09-09 11:32:58 +02:00
bors
6f34760e41 auto merge of #16903 : mahkoh/rust/move_items_unwrap, r=aturon
Closes #16879
2014-09-08 13:46:15 +00:00
Peter Marheine
0b53cc54e1 collections/slice: Reexport mut_ref_slice in addition to ref_slice. 2014-09-04 17:22:58 -06:00
Joseph Crail
b7bfe04b2d Fix spelling errors and capitalization. 2014-09-03 23:10:38 -04:00
bors
d59d97cbec auto merge of #16961 : huonw/rust/bitv-twiddle, r=alexcrichton
bitv: add larger tests, better benchmarks & remove dead code.

There were no tests for iteration etc. with more than 5 elements,
i.e. not even going beyond a single word. This situation is rectified.

Also, the only benchmarks for `set` were with a constant bit value,
which was not indicative of every situation, due to inlining & branch
removal. This adds a benchmark at the other end of the spectrum: random
input.
2014-09-04 01:11:04 +00:00
Huon Wilson
5c819186ed bitv: add larger tests, better benchmarks & remove dead code.
There were no tests for iteration etc. with more than 5 elements,
i.e. not even going beyond a single word. This situation is rectified.

Also, the only benchmarks for `set` were with a constant bit value,
which was not indicative of every situation, due to inlining & branch
removal. This adds a benchmark at the other end of the spectrum: random
input.
2014-09-03 20:07:08 +10:00
Andrew Poelstra
00ff5aac4e Rename RawPtr::to_option() to RawPtr::as_ref()
As outlined in

  https://aturon.github.io/style/naming/conversions.html

`to_` functions names should only be used for expensive operations.
Thus `to_option` is better named `as_option`. Also, putting type
names into method names is considered bad style; what the user is
really trying to get is a reference. This `as_ref` is even better.

Also, we are missing a mutable version of this method. So add a
new trait `RawMutPtr` with a corresponding `as_mut` methode.

Finally, there is a bug in the signature of `to_option` which has
been around since lifetime elision: originally the returned reference
had 'static lifetime, but since the elision changes this become
the lifetime of the raw pointer (which does not make sense, since
the pointer lifetime and referent lifetime are unrelated). Fix
the bug to return a reference with a fresh lifetime (which will
be inferred from the calling context).

[breaking-change]
2014-08-31 13:33:55 -05:00
Julian Orth
d34992ecba Add unwrap method to MoveItems 2014-08-31 17:27:49 +02:00
bors
f297366593 auto merge of #16859 : alexcrichton/rust/snapshots, r=huonw 2014-08-30 19:51:25 +00:00
Alex Crichton
d15d559739 Register new snapshots 2014-08-29 14:33:08 -07:00
P1start
ed2aad8b43 Add lint groups; define built-in lint groups bad_style and unused
This adds support for lint groups to the compiler. Lint groups are a way of
grouping a number of lints together under one name. For example, this also
defines a default lint for naming conventions, named `bad_style`. Writing
`#[allow(bad_style)]` is equivalent to writing
`#[allow(non_camel_case_types, non_snake_case, non_uppercase_statics)]`. These
lint groups can also be defined as a compiler plugin using the new
`Registry::register_lint_group` method.

This also adds two built-in lint groups, `bad_style` and `unused`. The contents
of these groups can be seen by running `rustc -W help`.
2014-08-30 09:12:04 +12:00
P1start
de7abd8824 Unify non-snake-case lints and non-uppercase statics lints
This unifies the `non_snake_case_functions` and `uppercase_variables` lints
into one lint, `non_snake_case`. It also now checks for non-snake-case modules.
This also extends the non-camel-case types lint to check type parameters, and
merges the `non_uppercase_pattern_statics` lint into the
`non_uppercase_statics` lint.

Because the `uppercase_variables` lint is now part of the `non_snake_case`
lint, all non-snake-case variables that start with lowercase characters (such
as `fooBar`) will now trigger the `non_snake_case` lint.

New code should be updated to use the new `non_snake_case` lint instead of the
previous `non_snake_case_functions` and `uppercase_variables` lints. All use of
the `non_uppercase_pattern_statics` should be replaced with the
`non_uppercase_statics` lint. Any code that previously contained non-snake-case
module or variable names should be updated to use snake case names or disable
the `non_snake_case` lint. Any code with non-camel-case type parameters should
be changed to use camel case or disable the `non_camel_case_types` lint.

[breaking-change]
2014-08-30 09:10:05 +12:00
bors
dee8423531 auto merge of #16768 : nham/rust/libcollections_test_cleanup, r=alexcrichton
unused imports.

This is mostly converting uses of `push_back`, `pop_back`, `shift` and `unshift` to `push`, `pop`, `remove` and `insert`.
2014-08-29 02:26:28 +00:00
bors
2e92c67dc0 auto merge of #16664 : aturon/rust/stabilize-option-result, r=alexcrichton
Per API meeting

  https://github.com/rust-lang/meeting-minutes/blob/master/Meeting-API-review-2014-08-13.md

# Changes to `core::option`

Most of the module is marked as stable or unstable; most of the unstable items are awaiting resolution of conventions issues.

However, a few methods have been deprecated, either due to lack of use or redundancy:

* `take_unwrap`, `get_ref` and `get_mut_ref` (redundant, and we prefer for this functionality to go through an explicit .unwrap)
* `filtered` and `while`
* `mutate` and `mutate_or_set`
* `collect`: this functionality is being moved to a new `FromIterator` impl.

# Changes to `core::result`

Most of the module is marked as stable or unstable; most of the unstable items are awaiting resolution of conventions issues.

* `collect`: this functionality is being moved to a new `FromIterator` impl.
* `fold_` is deprecated due to lack of use
* Several methods found in `core::option` are added here, including `iter`, `as_slice`, and variants.

Due to deprecations, this is a:

[breaking-change]
2014-08-28 23:56:20 +00:00
Aaron Turon
276b8b125d Fallout from stabilizing core::option 2014-08-28 09:12:54 -07:00
Niko Matsakis
1b487a8906 Implement generalized object and type parameter bounds (Fixes #16462) 2014-08-27 21:46:52 -04:00
nham
7b31058873 libcollections: In tests, remove some uses of deprecated methods and
unused imports.
2014-08-26 16:11:40 -04:00
Nick Cameron
52ef46251e Rebasing changes 2014-08-26 16:07:32 +12:00
Nick Cameron
3e626375d8 DST coercions and DST structs
[breaking-change]

1. The internal layout for traits has changed from (vtable, data) to (data, vtable). If you were relying on this in unsafe transmutes, you might get some very weird and apparently unrelated errors. You should not be doing this! Prefer not to do this at all, but if you must, you should use raw::TraitObject rather than hardcoding rustc's internal representation into your code.

2. The minimal type of reference-to-vec-literals (e.g., `&[1, 2, 3]`) is now a fixed size vec (e.g., `&[int, ..3]`) where it used to be an unsized vec (e.g., `&[int]`). If you want the unszied type, you must explicitly give the type (e.g., `let x: &[_] = &[1, 2, 3]`). Note in particular where multiple blocks must have the same type (e.g., if and else clauses, vec elements), the compiler will not coerce to the unsized type without a hint. E.g., `[&[1], &[1, 2]]` used to be a valid expression of type '[&[int]]'. It no longer type checks since the first element now has type `&[int, ..1]` and the second has type &[int, ..2]` which are incompatible.

3. The type of blocks (including functions) must be coercible to the expected type (used to be a subtype). Mostly this makes things more flexible and not less (in particular, in the case of coercing function bodies to the return type). However, in some rare cases, this is less flexible. TBH, I'm not exactly sure of the exact effects. I think the change causes us to resolve inferred type variables slightly earlier which might make us slightly more restrictive. Possibly it only affects blocks with unreachable code. E.g., `if ... { fail!(); "Hello" }` used to type check, it no longer does. The fix is to add a semicolon after the string.
2014-08-26 12:38:51 +12:00
Nick Cameron
37a94b80f2 Use temp vars for implicit coercion to ^[T] 2014-08-26 12:37:45 +12:00
Nick Cameron
34d607f9c9 Use the slice repr for ~[T] 2014-08-26 12:37:45 +12:00
bors
75396b2a06 auto merge of #16663 : Gankro/rust/heapify, r=alexcrichton
Heapify is O(n), extend as currently implemented is O(nlogn). No brainer.

Currently investigating whether extend can just be implemented as a local heapify.
2014-08-22 23:55:50 +00:00
Alexis Beingessner
b8dc103a95 make priorityqueue's from_iter use heapify 2014-08-21 20:17:45 -04:00
Vinzent Steinberg
da5e8cef59 bitv: make sure benchmarks run long enough
Previously they were too short (less than 10 ns), so the benchmarker
could not resolve them meaningfully. Now they should run in the order of
100 ns.
2014-08-21 10:09:36 -04:00
Vinzent Steinberg
c94bf8bb68 bitv: make benchmarks always return a value
This makes sure that the benchmarked code does not get optimized away.
Also fixed a typo.

Fixes #12118.
2014-08-21 10:09:36 -04:00
bors
51b901e160 auto merge of #16241 : P1start/rust/doc-fixes, r=alexcrichton
For crates `alloc`–`collections`. This is mostly just updating a few function/method descriptions to use the indicative style. 

cc #4361; I’ve sort of assumed that the third-person indicative style has been decided on, but I could update this to use the imperative style if that’s preferred, or even update this to remove all function-style-related changes. (I think that standardising on one thing, even if it’s not the ‘best’ option, is still better than having no standard at all.) The indicative style seems to be more common in the Rust standard library at the moment, especially in the newer modules (e.g. `collections::vec`), more popular in the discussion about it, and also more popular amongst other languages (see https://github.com/rust-lang/rust/issues/4361#issuecomment-33470215).
2014-08-19 20:25:49 +00:00
bors
9af4e325af auto merge of #16582 : Gankro/rust/bitv, r=alexcrichton
This was bothering me (and some other people). The macro was necessary in a transient step of my development, but I converged on a design where it was unnecessary, but it didn't really click that that had happened.

This fixes it up.
2014-08-19 08:35:55 +00:00
P1start
f2aa88ca06 A few minor documentation fixes 2014-08-19 17:22:18 +12:00
bors
ef5ad07272 auto merge of #16580 : steveklabnik/rust/gh1498, r=pcwalton
Fixes #14948
2014-08-19 01:26:14 +00:00
Alexis Beingessner
dcccf824b1 Fixing bitvset is_disjoint, fixes #16587 2014-08-18 17:05:26 -04:00
Alexis Beingessner
40c45169b7 Refactor BitV internals to not use macro, reduce duplication 2014-08-18 14:23:27 -04:00
Steve Klabnik
2f8044418e Remove innapropriate string mutability section.
Fixes #14948
2014-08-18 14:00:35 -04:00
Patrick Walton
67deb2e65e libsyntax: Remove the use foo = bar syntax from the language in favor
of `use bar as foo`.

Change all uses of `use foo = bar` to `use bar as foo`.

Implements RFC #47.

Closes #16461.

[breaking-change]
2014-08-18 09:19:10 -07:00
bors
01ec6fab21 auto merge of #16559 : Gankro/rust/bitv, r=pcwalton
These were the only differing-size-based errors I noticed. Might be more.
2014-08-18 00:46:10 +00:00
Alexis Beingessner
8c9bdda89b Correct internal BitvSet 0-padding, fixes #16542 2014-08-17 18:49:10 -04:00
bors
fb018a3d4b auto merge of #16550 : kaseyc/rust/fix_documentation_error, r=alexcrichton 2014-08-17 16:41:11 +00:00
bors
eff87bc9d2 auto merge of #16543 : huonw/rust/deprecated-btree, r=alexcrichton
This is very half-baked at the moment and very inefficient, e.g.
inappropriate use of by-value `self` (and thus being forced into an
overuse of `clone`). People get the wrong impression about Rust when
using it, e.g. that Rust cannot express what other languages can because
the implementation is inefficient: https://news.ycombinator.com/item?id=8187831 .
2014-08-17 13:11:06 +00:00
bors
cb9c1e0e70 auto merge of #16498 : Kimundi/rust/inline-utf-encoding, r=alexcrichton
The first commit improves code generation through a few changes:
- The `#[inline]` attributes allow llvm to constant fold the encoding step away in certain situations. For example, code like this changes from a call to `encode_utf8` in a inner loop to the pushing of a byte constant:

 ```rust
let mut s = String::new();
for _ in range(0u, 21) {
        s.push_char('a');
}
```
- Both methods changed their semantic from causing run time failure if the target buffer is not large enough to returning `None` instead. This makes llvm no longer emit code for causing failure for these methods.
- A few debug `assert!()` calls got removed because they affected code generation due to unwinding, and where basically unnecessary with today's sound handling of `char` as a Unicode scalar value.

~~The second commit is optional. It changes the methods from regular indexing with the `dst[i]` syntax to unsafe indexing with `dst.unsafe_mut_ref(i)`. This does not change code generation directly - in both cases llvm is smart enough to see that there can never be an out-of-bounds access. But it makes it emit a `nounwind` attribute for the function. 
However, I'm not sure whether that is a real improvement, so if there is any objection to this I'll remove the commit.~~

This changes how the methods behave on a too small buffer, so this is a 

[breaking-change]
2014-08-17 04:42:32 +00:00
Kasey Carrothers
9e514af07e Fix an error in a code sample in bitv.rs 2014-08-16 20:28:20 -07:00
Patrick Walton
7f928d150e librustc: Forbid external crates, imports, and/or items from being
declared with the same name in the same scope.

This breaks several common patterns. First are unused imports:

    use foo::bar;
    use baz::bar;

Change this code to the following:

    use baz::bar;

Second, this patch breaks globs that import names that are shadowed by
subsequent imports. For example:

    use foo::*; // including `bar`
    use baz::bar;

Change this code to remove the glob:

    use foo::{boo, quux};
    use baz::bar;

Or qualify all uses of `bar`:

    use foo::{boo, quux};
    use baz;

    ... baz::bar ...

Finally, this patch breaks code that, at top level, explicitly imports
`std` and doesn't disable the prelude.

    extern crate std;

Because the prelude imports `std` implicitly, there is no need to
explicitly import it; just remove such directives.

The old behavior can be opted into via the `import_shadowing` feature
gate. Use of this feature gate is discouraged.

This implements RFC #116.

Closes #16464.

[breaking-change]
2014-08-16 19:32:25 -07:00
Huon Wilson
7b141ad99b collections: deprecate BTree.
This is very half-baked at the moment and very inefficient, e.g.
inappropriate use of by-value `self` (and thus being forced into an
overuse of `clone`). People get the wrong impression about Rust when
using it, e.g. that Rust cannot express what other languages can because
the implementation is inefficient.
2014-08-17 10:16:48 +10:00
Marvin Löbel
13079c1a85 Optimized IR generation for UTF-8 and UTF-16 encoding
- Both can now be inlined and constant folded away
- Both can no longer cause failure
- Both now return an `Option` instead

Removed debug `assert!()`s over the valid ranges of a `char`
- It affected optimizations due to unwinding
- Char handling is now sound enought that they became uneccessary
2014-08-16 21:13:39 +02:00
Brian Anderson
fce442e75c Fix test fallout 2014-08-13 17:11:21 -07:00
Brian Anderson
4e1024f8d3 core: Put stability attributes all over the slice module
Much of this is as discussed[1]. Many things are marked

[1]: https://github.com/rust-lang/meeting-minutes/blob/master/Meeting-API-review-2014-08-06.md
2014-08-13 15:27:34 -07:00
Brian Anderson
a4b354ca02 core: Add binary_search and binary_search_elem methods to slices.
These are like the existing bsearch methods but if the search fails,
it returns the next insertion point.

The new `binary_search` returns a `BinarySearchResult` that is either
`Found` or `NotFound`. For convenience, the `found` and `not_found`
methods convert to `Option`, ala `Result`.

Deprecate bsearch and bsearch_elem.
2014-08-13 11:30:15 -07:00
Brian Anderson
76d46af6d4 core: Rename ImmutableEqSlice to ImmutablePartialEqSlice
This is in the prelude and won't break much code.

[breaking-change]
2014-08-13 11:30:15 -07:00
Brian Anderson
12e851208d collections: Deprecate Vec::tailn. Same as slice_from 2014-08-13 11:30:15 -07:00
Brian Anderson
033f28d436 core: Rename ImmutableSlice::unsafe_ref to unsafe_get
Deprecate the previous.
2014-08-13 11:30:14 -07:00
Brian Anderson
fbc93082ec std: Rename slice::Vector to Slice
This required some contortions because importing both raw::Slice
and slice::Slice makes rustc crash.

Since `Slice` is in the prelude, this renaming is unlikely to
casue breakage.

[breaking-change]
2014-08-13 11:30:14 -07:00
Brian Anderson
4f5b6927e8 std: Rename various slice traits for consistency
ImmutableVector -> ImmutableSlice
ImmutableEqVector -> ImmutableEqSlice
ImmutableOrdVector -> ImmutableOrdSlice
MutableVector -> MutableSlice
MutableVectorAllocating -> MutableSliceAllocating
MutableCloneableVector -> MutableCloneableSlice
MutableOrdVector -> MutableOrdSlice

These are all in the prelude so most code will not break.

[breaking-change]
2014-08-13 11:30:14 -07:00
Aaron Turon
f77cabecbb Deprecation fallout in libcollections 2014-08-12 13:35:56 -07:00
bors
e8204a84c7 auto merge of #16195 : P1start/rust/more-index, r=aturon
Implement `Index` for `RingBuf`, `HashMap`, `TreeMap`, `SmallIntMap`, and `TrieMap`.

If there’s anything that I missed or should be removed, let me know.
2014-08-12 05:11:18 +00:00
P1start
8f71cb06bc Implement Index for TrieMap 2014-08-12 15:33:05 +12:00
P1start
11b8f9c3f6 Implement Index for SmallIntMap
This also deprecates SmallIntMap::get. Use indexing instead.
2014-08-12 15:33:05 +12:00
P1start
2dd6bc6887 Implement Index for TreeMap 2014-08-12 15:33:05 +12:00
P1start
fd10d209cd Implement Index for RingBuf
This also deprecates RingBuf::get. Use indexing instead.
2014-08-12 15:32:56 +12:00
bors
9dcf89567e auto merge of #16417 : jasonthompson/rust/docs/slice3, r=alexcrichton
- Moved examples for permutations and next into trait definition as
   comments on pull request #16244.
- Fixed (hopefully) issue with erronious commit of changes to src/llvm.
2014-08-12 00:26:13 +00:00
Jason Thompson
371e8cf273 API docs/examples for std::slice
- API doc/example for next() in Permutations
 - API doc/example for permutations() in ImmutableCloneableVector
 - Moved examples for permutations and next into trait definition as
   comments on pull request #16244.
 - Fix erroneus inclusion of src/llvm in older commit.
2014-08-11 06:49:00 -04:00
bors
39bafb09fd auto merge of #16314 : Ryman/rust/ringbuf_non_pow2, r=huonw
See test for details.
2014-08-09 01:21:23 +00:00
bors
3b1f983584 auto merge of #16325 : froydnj/rust/vec-grammar-fix, r=alexcrichton
Just a small typo noticed while reading through documentation.
2014-08-08 11:06:12 +00:00
bors
0ba2d04224 auto merge of #16279 : nham/rust/fix_slice_docs, r=alexcrichton
This does a few things:

 - remove references to ~[] and the OwnedVector trait, which are both
   obsolete
 - correct the docs to say that this is the slice module, not the vec
   module
 - add a sentence pointing out that vectors are distinct from Vec
 - remove documentation on Vec.

closes #15459
2014-08-08 05:41:15 +00:00
nham
cb0aa8ac71 Cleanup collections::slice documentation.
This does a few things:

 - remove references to ~[] and the OwnedVector trait, which are both
   obsolete
 - correct the docs to say that this is the slice module, not the vec
   module
 - add a sentence pointing out that vectors are distinct from Vec
 - remove documentation on Vec.

closes #15459
2014-08-07 23:45:39 -04:00
Nathan Froyd
0d974eecd3 fix grammar in Vec.retain's doc comment 2014-08-07 11:27:06 -04:00
Kevin Butler
64896d6103 libcollections: Fix RingBuf growth for non-power-of-two capacities 2014-08-07 02:11:13 +01:00
nham
f36ddf1d0e Use byte literals in libcollections tests 2014-08-06 00:57:49 -04:00
bors
efe1f7ee9e auto merge of #15986 : Florob/rust/nfKc-new, r=alexcrichton
This adds a new `Recompositions` iterator, which performs canonical composition on the result of the `Decompositions` iterator (which is canonical or compatibility decomposition). In effect this implements Unicode normalization forms C and KC.
2014-08-04 17:06:19 +00:00
bors
845ff6567f auto merge of #16203 : Gankro/rust/vec_flow, r=alexcrichton
fixes #16200
2014-08-03 11:36:07 +00:00
bors
756b7b23c4 auto merge of #16180 : jbcrail/rust/fix-comments, r=steveklabnik 2014-08-02 21:51:10 +00:00
Alexis Beingessner
d9b2e6b74f fix underflow in vec swap_remove
fixes #16200
2014-08-02 14:50:29 -04:00
bors
87bc22f587 auto merge of #16177 : nham/rust/collections_15294_eq_ord, r=alexcrichton
This implements:

 - Eq and Ord for DList, RingBuf, TreeMap and TreeSet
 - FromIterator and Extendable for BitvSet

cc #15294
2014-08-02 13:51:09 +00:00
Joseph Crail
ad06dfe496 Fix misspelled comments. 2014-08-01 19:42:52 -04:00
nham
a0438143de collections: Implement FromIterator/Extendable for BitvSet 2014-08-01 16:51:49 -04:00
nham
3737c537c3 collections: Implement Ord for DList, RingBuf, TreeMap, TreeSet 2014-08-01 16:51:26 -04:00
nham
25acfde398 collections: Implement Eq for DList, RingBuf, TreeMap, TreeSet 2014-08-01 16:05:03 -04:00
bors
6136381ed8 auto merge of #16102 : zwarich/rust/borrowck-unboxed, r=pcwalton
This removes the ability of the borrow checker to determine that repeated dereferences of a Box<T> refer to the same memory object.
2014-08-01 18:36:01 +00:00
Patrick Walton
5b85c8cbe7 librustc: Forbid pattern bindings after @s, for memory safety.
This is an alternative to upgrading the way rvalues are handled in the
borrow check. Making rvalues handled more like lvalues in the borrow
check caused numerous problems related to double mutable borrows and
rvalue scopes. Rather than come up with more borrow check rules to try
to solve these problems, I decided to just forbid pattern bindings after
`@`. This affected fewer than 10 lines of code in the compiler and
libraries.

This breaks code like:

    match x {
        y @ z => { ... }
    }

    match a {
        b @ Some(c) => { ... }
    }

Change this code to use nested `match` or `let` expressions. For
example:

    match x {
        y => {
            let z = y;
            ...
        }
    }

    match a {
        Some(c) => {
            let b = Some(c);
            ...
        }
    }

Closes #14587.

[breaking-change]
2014-08-01 08:45:22 -07:00
Cameron Zwarich
8da03d9771 Library changes for RFC #43 2014-07-30 13:36:21 -07:00
bors
f681420624 auto merge of #15915 : erickt/rust/master, r=alexcrichton
std: rename MemWriter to SeekableMemWriter, add seekless MemWriter

Not all users of MemWriter need to seek, but having MemWriter seekable adds between 3-29% in overhead in certain circumstances. This fixes that performance gap by making a non-seekable MemWriter, and creating a new SeekableMemWriter for those circumstances when that functionality is actually needed.

```
test io::mem::test::bench_buf_reader                        ... bench:       682 ns/iter (+/- 85)
test io::mem::test::bench_buf_writer                        ... bench:       580 ns/iter (+/- 57)
test io::mem::test::bench_mem_reader                        ... bench:       793 ns/iter (+/- 99)
test io::mem::test::bench_mem_writer_001_0000               ... bench:        48 ns/iter (+/- 27)
test io::mem::test::bench_mem_writer_001_0010               ... bench:        65 ns/iter (+/- 27) = 153 MB/s
test io::mem::test::bench_mem_writer_001_0100               ... bench:       132 ns/iter (+/- 12) = 757 MB/s
test io::mem::test::bench_mem_writer_001_1000               ... bench:       802 ns/iter (+/- 151) = 1246 MB/s
test io::mem::test::bench_mem_writer_100_0000               ... bench:       481 ns/iter (+/- 28)
test io::mem::test::bench_mem_writer_100_0010               ... bench:      1957 ns/iter (+/- 126) = 510 MB/s
test io::mem::test::bench_mem_writer_100_0100               ... bench:      8222 ns/iter (+/- 434) = 1216 MB/s
test io::mem::test::bench_mem_writer_100_1000               ... bench:     82496 ns/iter (+/- 11191) = 1212 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0000      ... bench:        48 ns/iter (+/- 2)
test io::mem::test::bench_seekable_mem_writer_001_0010      ... bench:        64 ns/iter (+/- 2) = 156 MB/s
test io::mem::test::bench_seekable_mem_writer_001_0100      ... bench:       129 ns/iter (+/- 7) = 775 MB/s
test io::mem::test::bench_seekable_mem_writer_001_1000      ... bench:       801 ns/iter (+/- 159) = 1248 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0000      ... bench:       711 ns/iter (+/- 51)
test io::mem::test::bench_seekable_mem_writer_100_0010      ... bench:      2532 ns/iter (+/- 227) = 394 MB/s
test io::mem::test::bench_seekable_mem_writer_100_0100      ... bench:      8962 ns/iter (+/- 947) = 1115 MB/s
test io::mem::test::bench_seekable_mem_writer_100_1000      ... bench:     85086 ns/iter (+/- 11555) = 1175 MB/s
```
2014-07-30 14:41:18 +00:00
Erick Tryzelaar
a011b2273e Fix a whitespace typo 2014-07-29 15:50:44 -07:00
nham
f7bcb736ad Implement Hash for DList 2014-07-29 15:44:37 -07:00
donkopotamus
57fef0f708 Fix documentation error in MutableVectorAllocating::move_from
Correct `str` to `src`
2014-07-29 15:44:05 -07:00
bors
7375f4d842 auto merge of #16038 : nham/rust/collections_partialord, r=alexcrichton
cc #15294
2014-07-29 07:56:41 +00:00
bors
f653d9f9bf auto merge of #16033 : nham/rust/hash_tuple_impl, r=alexcrichton
Previously the implementation of Hash was limited to tuples of up to arity 8. This increases it to tuples of up to arity 12. 

Also, the implementation macro for `Hash` used to expand to something like this:

    impl Hash for (a7,)
    impl Hash for (a6, a7)
    impl Hash for (a5, a6, a7)
    ...

This style is inconsistent with the implementations in core::tuple, which look like this:

    impl Trait for (A,)
    impl Trait for (A, B)
    impl Trait for (A, B, C)
    ...

This is perhaps a minor point, but it does mean the documentation pages are inconsistent. Compare the tuple implementations in the documentation for [Hash](http://static.rust-lang.org/doc/master/std/hash/trait.Hash.html) and [PartialOrd](http://static.rust-lang.org/doc/master/core/cmp/trait.PartialOrd.html)

This changes the Hash implementation to be consistent with `core::tuple`.
2014-07-29 04:26:42 +00:00
bors
9e250109f9 auto merge of #16032 : treeman/rust/doc-treecollection, r=alexcrichton 2014-07-29 02:41:41 +00:00
bors
b2bd998607 auto merge of #16027 : treeman/rust/doc-string, r=alexcrichton 2014-07-28 22:36:39 +00:00
Florian Zeitz
7ece0abe64 collections, unicode: Add support for NFC and NFKC 2014-07-28 18:47:38 +02:00
Jonas Hietala
3f56846460 doc: Method examples for String
Reword comments on unsafe methods regarding UTF-8.
2014-07-28 17:03:12 +02:00
nham
8ebd58cedf Implement Ord for TrieMap/TrieSet/SmallIntMap/Bitv/BitvSet 2014-07-28 02:53:44 -04:00
nham
935c88ce1c Implement PartialOrd for Bitv and BitvSet 2014-07-28 00:28:49 -04:00
nham
220f8f6dcb Implement PartialOrd for SmallIntMap 2014-07-28 00:00:29 -04:00
nham
16acc10bf9 Implement PartialOrd for TrieMap and TrieSet 2014-07-27 23:51:28 -04:00