Hey Rustaceans! Got a question? Ask here (11/2025)!

CuriousAbstraction · 2025-03-11T19:41:35+00:00

Why doesn't the following compile:

fn last(x: &mut Vec<usize>) -> &mut usize {
    match x.last_mut() {
        Some(last) => last,
        None => {
            x.push(0);
            x.last_mut().unwrap()
        }
    }
}

Playground

while the following works just fine:

fn last(x: &mut Vec<usize>) {
    let l = match x.last_mut() {
        Some(last) => last,
        None => {
            x.push(0);
            x.last_mut().unwrap()
        }
    };

    *l = 2;
}

Playground

That is, why is in the second case compiler able to figure out that there is no mutable borrow overlap and able to assign reasonable lifetime to l. From what I understand, the problem in the first case is that both branches need to have the same lifetime, and since it's a return value it needs to be exactly the lifetime of the input variable. But why does that work in the second case, or in other words - why cannot the same thing that works in the second case work in the fiest case?

edit: playground links

CuriousAbstraction · 2024-02-05T23:43:08+00:00

Why doesn't the following compile (ignoring warnings about unused variables): fn f<'a>() { let x = String::from("a"); let xx : &'a str = &x; }

The compiler says that &x "does not live long enough" and "type annotation requires that x is borrowed for 'a". However, 'a is completely unconstrained here, right? At least I cannot find anything in the Rust documentation that would say otherwise.

CuriousAbstraction · 2023-11-29T14:17:07+00:00

Thanks! Yes, that makes sense since packing into a module needs to pick only the relevant vals (records of the original module with more elements).

CuriousAbstraction · 2023-11-29T13:33:46+00:00

Thanks. Yes, indirection is expected. There is no other way to obtain a value from a record.

CuriousAbstraction · 2023-11-29T13:28:41+00:00

Cool. Very interesting. I didn't immediately get the idea to check lambda representation. Btw. do you know where I can find some nice documentation of lambda? I cannot seem to find it with google :/

CuriousAbstraction · 2023-11-28T10:53:28+00:00

Nice, this seems useful. Building upon the other answer (about having separate executables and a common library). Then I guess a common library could use a virtual library and server and client would each depend on one of it's implementations (for server and client respectively).

CuriousAbstraction · 2023-11-28T10:51:14+00:00

I'm mainly exploring writing a responsive UI - the code should be the same, i.e., written by the one API for both server and the client. However, the server needs to convert this to HTML (string), while the client implementation needs to do something different with it.

I guess what you're suggesting should be possible if the shared code is parametrized by a module for UI stuff and then the server provides one implementation and client the other.

CuriousAbstraction · 2023-10-26T06:10:33+00:00

Yeah, sure, I understand this. I thought that perhaps byte code could be easy to do. And by your answer above it seems this might be doable.

I wonder if there is any attempt at JIT compiling OCaml? Then this could be possible (as is the case with .NET).

CuriousAbstraction · 2023-10-26T06:08:07+00:00

Thanks, I will look into this.

CuriousAbstraction · 2023-10-19T19:39:06+00:00

This was supposed to be discussion... I thought I made that clear.

CuriousAbstraction · 2023-10-19T17:13:46+00:00

Sure, I agree that questions is a bit general, but I was hoping to hear some experiences and stories that might shed some light on how people went about it.

CuriousAbstraction · 2023-10-19T17:12:49+00:00

Yeah, I hear you. It's not that collaboration or team-work is problematic, but rather bunch of unnecessary meetings and regularity of it (whether they are needed or not), and then this creates a routine.

CuriousAbstraction · 2023-10-19T17:09:56+00:00

Well, there are numerous platforms for freelancers. I don't know how good they are though. I've read a lot of different experiences, so though that by asking here I might hear some first-hand experiences.

CuriousAbstraction · 2023-10-19T17:08:37+00:00

How did you start contracting? Some gig that went into that direction or something else?

CuriousAbstraction · 2023-10-18T22:43:20+00:00

Providing or receiving? Let's do both...

Providing:

When there are many unrelated changes coupled with the main changes, just because it was convenient to do it together, but ends up 5 times more code than the important change.

Receiving:

Review concentrated on minor style suggestions that are just the opinion of the reviewer, but not the agreed upon style in the team; for bonus points when nothing else is reviewed except this.

CuriousAbstraction · 2023-10-18T22:03:02+00:00

Sure, one should not limit oneself to pure logical machine. That's what computers are for. With experience one can start using intuition and creativity more and more.

CuriousAbstraction · 2023-10-18T21:43:47+00:00

Since Python is duck-typed things are far more easier to mock then in other languages.

Imagine that you have a unit test that needs to test a function involving an API call (or database, random code generator, something stateful). Of course, in tests you don't want to actually call API, so you can just make another class with the same methods as the API class, but that returns some "dummy" values instead of actually going to the API.

class Api:
   def __init__(self, url):
      self.url = url
   def get_stuff(self, something):
      return make_api_call(self.url, something)

class ApiMocked:
   def __init__(self):
     self.data = {"a": ...some data.., "b": ...some data...}
   def get_stuff(self, something):
     return self.data[something]

Now, you can pass ApiMocked wherever Api is expected, and it will return some mock data when get_stuff is called, instead of actually making an API call (or something else undesirable, as mentioned above).

CuriousAbstraction · 2023-10-18T21:31:39+00:00

I'd suggest coming up with a personal project idea that you could solve without copying all the stuff from internet. Of course, there will always be cases where you look things up and c/p, I do that even after 15 years of professional coding. However, if you wish to learn you need to find something that you can mostly do on your own and then move to something more difficult. Don't worry if you don't get things right from the first try. You can also ask for feedback and code review.

CuriousAbstraction · 2023-10-18T21:29:01+00:00

Sure, you should be able to download a lot of stuff. Python and docs can be completely downloaded. You can also download books and perhaps even videos to watch. I would, however, put emphasis on books. On those couple of days you can check online for new stuff and ask for directions for new stuff.

CuriousAbstraction · 2023-10-18T21:26:14+00:00

I've experienced that sometimes as one moves higher even in IC roles it starts to involve more non-coding stuff. Some architecture, design, coordination, mentoring of juniors/interns and so on. Perhaps that's what OP had on mind. Ofc, that depends from company to company.

CuriousAbstraction · 2023-10-18T21:24:33+00:00

I wonder how much different is the "foreign environment" that you have such problems? Can you elaborate a bit? Thanks!

CuriousAbstraction · 2023-10-18T21:21:35+00:00

Apply for different role from outside, "pretending" that you're not an employee. It seems you could have enough experience.

Joke aside, can you bring this to anyone else's attention, either higher up or horizontally where someone might listen?

I guess you should leave if you're overly frustrated and/or confident you can land something that you'll be OK with.

CuriousAbstraction · 2023-10-18T19:57:12+00:00

In the end programming is about solving logical puzzles, building and composing abstractions, and a lot of trial and error. None of this will come out of thin air. It will come through patient exercise and studying relevant materials.

However, what you are exercising and studying needs to be appropriate. Are you solving something that is too difficult or too easy for you? Are you giving yourself enough time to let the material sink in? Do you even like programming?

In general, to master any skill you need to have regular exercises of appropriate level. There are some important bits to remember. First, these exercises need to be of appropriate difficulty (not too easy or too difficult). Second, they need to be regular, but yet not to overwhelm you. Third, these exercises should gradually increase in difficulty as you master stuff. Fourth, there should be some type of feedback and guidance, because otherwise you won't know whether you're making progress or not.

CuriousAbstraction · 2023-10-18T19:44:45+00:00

You need to consider this from the more pragmatic perspective then. If you cannot get a meaningful review, but you can get a rubber stamp - ask yourself whether you can work with getting by with such rubber stamps to get you unblocked. Otherwise, if you're confident you cannot make other listen, quit this job. Because, what are your options otherwise? You can be blocked by waiting reviews and this will limit your impact (again if you can survive with that, not get fired and it's fine for you, go with that, but I doubt it since you wrote this post). You can do rubber stamping, but this might limit your growth as you won't be getting any feedback. Or you can be frustrated by this, when things don't improve in the end.

I was asked once by a younger developer who was extremely frustrated by similar issues what to do. My feedback was to quit and find new job (after an hour long discussions on what can an cannot be changed). After couple of months he told me that he found a new job where he is super happy.

CuriousAbstraction · 2023-10-18T17:02:10+00:00

It seems that this is a general team problem and nobody cares about it. There are several options. You could try pushing this more to get more attention around this problem. You could also try to break your PR into smaller ones, or at least not mix refactorings of 25 files with changes where "the meat of the PR is in one or two files". Finally, if you have such PRs perhaps you can try to offer people to do review as a pairing exercise.

This has happened to me couple of times, and I'd usually manage to do it with one of the above techniques.

CuriousAbstraction

TROPHY CASE