On 07/14/2014 09:56 PM, Chris Morgan wrote:
> On Tue, Jul 15, 2014 at 4:16 AM, Brian Anderson wrote:
>> Can somebody file an issue described exactly what we should do and cc me?
>
> Nothing. Absolutely nothing.
>
> robots.txt rules do not apply to historical data; if archive.org has
> archived s
On 6/12/14 11:15 AM, Tommi wrote:
But I think it will be easy to make the error of writing the explicit
.clone() in places where it's not needed. For example:
[...]
Would a compiler warning for unnecessary clones be feasible? useful?
Would it have false positives -- situations where a clone wo
Hi all, I don't suggest seeing Javascript as a great example for Rust.
It uses UTF-16, but was created back when UTF-16 was UCS-2, so
two-code-unit codepoints are poorly supported in Javascript (e.g. you
can't use them in regex character classes).
On 05/29/2014 12:16 AM, Bardur Arantsson wrote
On 02/01/2014 06:27 AM, Matthieu Monrocq wrote:
In short, isn't there a risk of crashes if one accidentally links two
versions of a given library and start exchanging objects ? It seems
impractical to prove that objects created by one version cannot
accidentally end up being passed to the other v
Another sweet spot for a few applications is larger-than-word-sized
fixed-width types, such as a 128 or 192 bit (u)int. This is useful for
code that has to deal with values larger than 64 bits but within, say,
256 or 512 bits (above this, I think the costs of dynamic allocation and
non-inlined
Scheme's numeric tower is one of the best in extant languages. Take a
look at it. Of course, its dynamic typing is poorly suited for Rust.
Arbitrary-precision arithmetic can get you mathematically perfect
integers and rational numbers, but not real numbers. There are an
uncountably infinite
On 12/04/2013 03:36 PM, Bill Myers wrote:
Hello, I already implemented a persistent tree-map called SnapMap: you
can find the source code at https://github.com/mozilla/rust/pull/9816
I stopped working on it before I made a serious effort to push it into
the Rust codebase and don't have time to w
On 12/04/2013 02:09 PM, Michael Woerister wrote:
Is it
possible for the structure to be parametrized on smart pointer?
Not without higher kinded types (which eventually we do want--so the
answer is "not yet").
And then we can define a container type, using the generic reference type:
struct
I'm interested in having persistent data structures[1] in Rust. To
start, I implemented the simplest one, the cons/nil list (it looks like
extra::list::List has another implementation of it). Am I using Rust
conventions properly?
My persistent list code:
https://github.com/idupree/rust-code/
On 11/15/2013 11:05 AM, Gábor Lehel wrote:
Like C++, types could be parameterized over constants. Again, the syntax
could mirror their declarations. For example, a function to construct a
fixed-length array:
fn make_n(n: int) -> ~[int, ..N] { [n, ..N] }
Interesting questions here include w
On 11/14/2013 09:25 PM, Tommi wrote:
trait Inflate {
fn get_radius<'s>(&'s mut self) -> &'s mut int;
fn inflate_by(&mut self, amount: int) {
*self.get_radius() += amount;
}
}
[...]
Third time's the charm. One more detail was still missing:
struct Inflate {
virtual void
11 matches
Mail list logo