On 07/14/2014 09:56 PM, Chris Morgan wrote:
On Tue, Jul 15, 2014 at 4:16 AM, Brian Anderson bander...@mozilla.com 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
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
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
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
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
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
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
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
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:
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_nstatic N: int(n: int) - ~[int, ..N] { [n, ..N] }
Interesting questions
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
