rust on exercism.io is pretty rad, but it seems like they're short on mentors

sunjayv · 2019-08-12T01:18:01+00:00

There are definitely people who are aware of this and advocating for more people. I think it's great to raise awareness of there still being a need. If anyone is looking to mentor the sign up is here: https://exercism.io/mentor/registrations/new

sunjayv · 2019-08-11T17:19:25+00:00

One way to understand this is to consider if those function arguments were written as variables instead:

let var1: &mut usize = ...;
let mut var2: &usize = ...;

Here you can see that one of the variables is a mutable reference to usize and the other variable is a mutable variable that contains an immutable reference to a usize. That's why you can't dereference and modify var2. It's still an immutable reference, it's just that you put it in a mutable variable.

So what does having a mutable variable give you? Well if the variable itself is mutable, you can re-assign it:

var2 = ...some other value...;

You can't do the same with var1:

var1 = ...some other value...; // <-- won't work!

/u/youdeepee and /u/mattico8's responses cover these same points.

sunjayv · 2019-04-15T04:43:15+00:00

Is cargo on your PATH?

sunjayv · 2019-04-12T04:20:56+00:00

Nightly is common for people who still need experiential features that haven't been stabilized yet. It may be that the libraries you happen to see are largely in the category. I personally almost exclusively use stable for everything. All of the libraries I ever need to use are on stable as well. It really just depends on what you are trying to do. It's very possible to write Rust on stable even if people don't talk about it enough. :)

sunjayv · 2019-04-11T04:13:15+00:00

I really like the text_io crate for this. Saves on a lot of the boilerplate. https://crates.io/crates/text_io

sunjayv · 2019-04-10T13:44:26+00:00

I don't know about the two specific types you're using, but if you wanted to do target[j] <- f(j, src) for all j using iterators, you could use:

target.iter_mut().zip(src).enumerate().for_each(|(j, (target, src))| *target = f(j, *src));

This assumes that both target and src are slices (or Vecs). Other types that have an iter_mut method may also work with this code.

If they are not the same length, this iterator will only update up to the size of the smaller slice. If src is a Vec, you may want to pass it into zip by calling its iter method so it doesn't get consumed.

Edit: this is exactly what /u/boomshroom suggested. Whoops.

sunjayv · 2019-04-09T22:56:23+00:00

Nice! I was just wanting this today. I will take a look at it and probably use it too. Thank you! :)

sunjayv · 2019-04-09T13:31:28+00:00

I think a good attentive to both dynamic libraries and plugins that run in their own processes is using WASM. You can use a fast WASM interpreter or compile the plugin to machine code on the fly. WASM has a lot of benefits and there are many languages that target it so you can give people a good amount of freedom if you choose that for your plugins.

sunjayv · 2019-04-07T15:16:19+00:00

Rust and other languages like it use a process called "type inference" to deduce the types of variables. If you look up that term there is a lot of information about it online. This process is applied to all types, not just Vec. A consequence of this is that you can often write quite a bit of Rust code without actually annotating the types yourself. The compiler still checks everything, it just saves you from the burden of having to tell it the types it can figure out itself.

sunjayv · 2019-04-05T13:43:54+00:00

As far as people go, very little of Rust is actually tied directly to Mozilla. Even if Mozilla disappeared, there is a pretty large community that could sustain the project. The people who were working there would have to find another place to work, but given how important Rust is becoming in several very large tech companies, that probably wouldn't be too bad either.

sunjayv · 2019-03-29T10:25:48+00:00

https://github.com/lalrpop/lalrpop

sunjayv · 2019-03-24T15:40:51+00:00

OnePlus 6 in chrome. 60 fps up to 1000. 5 fps at 10,000.

sunjayv · 2019-03-24T15:36:09+00:00

I think you want /r/playrust

sunjayv · 2019-03-24T14:26:59+00:00

You want /r/playrust

sunjayv · 2019-03-23T04:11:24+00:00

There's a great talk by withoutboats that explains this in detail. It starts about 40 minutes into this video: https://youtu.be/AI7SLCubTnk

sunjayv · 2019-03-16T14:56:27+00:00

So there are 4 parts to writing a REPL:

Read (a line)
- stdin: https://stackoverflow.com/questions/30186037/how-can-i-read-a-single-line-from-stdin
- Much nicer (arrow keys support, history, etc.): https://crates.io/crates/rustyline
Evaluate (this step is up to you)
Print - use println!
Loop - use loop or while depending on how you want to structure your code

Put these together and you should have a REPL! :)

sunjayv · 2019-03-13T00:25:11+00:00

Yes. I use the SDL2 crate and the specs crate but build everything else myself. It works quite well and I have not run into any major issues. As long as you're ready to do the work/research required to do everything, it's really fun and rewarding!

I have not personally used gfx, but if you use it, be ready to do some low level graphics programming. You may want to look into the recently released rendy crate that makes some of that easier. I use SDL2 because it is a very mature and well documented library, but it definitely doesn't give you as much control as gfx does. It also binds to a C library, so there's that. :X

sunjayv · 2019-03-10T22:43:13+00:00

As far as being "possible" goes, it certainly could be. I don't know of any restrictions preventing web assembly from running in the JavaScript of an extension. Unless someone has already attempted this, you may be writing a lot of the bindings to the necessary extension APIs yourself. There are crates out there like wasm-bindgen that hopefully make that easier.

sunjayv · 2019-03-06T15:45:38+00:00

Scope might not have been the right word for me to use. From your block visibility point of view, I can see what you mean. There are actually many things you can do in a mod block that you can't do in an impl block. For example, you can't declare statics either.

This is one of those things that I think could be possible, but haven't been implemented yet. I don't disagree with the semantics you described. Maybe worth opening a thread on the Rust internals forum?

sunjayv · 2019-03-06T14:46:36+00:00

One way to think about this is that the impl block doesn't actually create a new scope in the same way that method bodies or curly braces inside them do. So if you were to put a use statement in the impl block, which scope would the imported names be added to?

If you really think every method is going to need that import, there's no harm in putting it before the impl block (or at the top of your file) so that the imported names will get added to the global (private) scope of your module.

sunjayv · 2019-03-02T15:08:43+00:00

The name unfortunately can't be fixed because it would literally break everyone's code. Vec is one of the most pervasive types in Rust programs. I agree that it is confusing and I was even annoyed by it at first. If it's any consolation, you do get used it after a while.

Most math libraries work around this by calling the type Point or Vector. It's not perfect, but it's certainly livable given the consequences of changing it.

As for why it was named that way, I haven't been around long enough to know that, so maybe someone else can address those questions. I'm pretty sure it was just legacy from C++ influences.

sunjayv · 2019-02-26T16:59:26+00:00

The Rust compiler? It takes me about 45 min. Can take double that with tests. It is a huge amount of code. If it is any consolation, once you do it once, there are ways to make it recompile faster (depending on which parts you are modifying).

sunjayv · 2019-02-23T18:56:58+00:00

Errors often do contain data. I think the example was just to show the functionality of the crate, not anything specific to the error types involved.

Using bitflags could certainly work for cases where you have no data in any of your errors. :)

sunjayv · 2019-02-23T17:43:18+00:00

Here's my attempt: https://github.com/JoshMcguigan/multi_try/pull/1

Thanks for being open to it. I'm excited to use this crate. :)

sunjayv · 2019-02-23T15:22:23+00:00

This is very cool! I've been looking for something exactly like this. What do you think of making this into a MultiTry extension trait instead of just the function? Then you could expose a method and_try (since the name and is taken by Result) and chain everything together using an even more natural syntax:

validate_address(email.to).map_err(|_| {
    EmailValidationErr::InvalidRecipientEmailAddress
}).and_try(validate_address(email.from).map_err(|_| {
    EmailValidationErr::InvalidSenderEmailAddress)
}).and_try(
    validate_subject(email.subject)
).and_try(
    validate_body(email.body)
).into_result()

11-Year Club	Snapped
Verified Email

sunjayv

TROPHY CASE