@jose_exposito As Rust is really good at inferring logic, I’m surprised that it couldn’t just infer the PartialEq trait for simple enums.

@michaelphamct @acmel I will admit that I should have just started to learn to program Rust before learning the details of its implementation. But, here I am ;-)

@michaelphamct @acmel

Yes, your book is probably better to learn the language. And I wouldn’t recommend the book I’m using to just learn to program in Rust. But I like the book, because I am interested in how rust works. I want to get as good at rust as I am with C. With most C programs, I can usually visualize what the assembly output would be. I don’t have that with Rust. And this book is useful to have in order to get that kind of understanding of the language.

@jose_exposito That should be the default. I’m finding that I’ll be adding lots of #[derive(...)] all over the place.

@vbabka OK, i got recursion working. I don’t know what went wrong before. Perhaps it detected right away that a bug in my code would do an infinite recursion and failed out. Unfortunately, it didn’t quite tell me what that infinite condition was :-(

Although I’m ranting here, I also want to add what I really like. The RUST_BACKTRACE environment variable creating a nice backtrace on assert!() errors, is really nice!

Another annoyance is that you can’t compare enums.

use self::Direction::*;
enum Direction { UP, DOWN, LEFT, RIGHT};

fn foo (dir: Direction) {
     if (dir == DOWN) { ... }  <<--- Error!
}

But instead you must do:

   if matches!(dir, DOWN) { ... }

@aissen Moves something ;-)

@vbabka I immediately got a “Stack overflow” and the println! only went 3 deep. Maybe it was smarter to know it would go further?

@acmel Rust is very much becoming dominate (especially by my employer). I like the guarantees that Rust brings, so I’m working on learning it. I bought a book on Rust, which really gets into the details of the language, but honestly, isn’t a good way to learn the language. I found that learning by example is a much better approach.

I have a non trivial program I’m writing (it was one of the programs I had to write for my interview), and I’m hitting all the fun corner cases with it. I’m trying hard to keep an open mind, but for someone that’s been programming C for over 3 decades, it’s really hard to do so. ;-)

@ljs @acmel I thought that cover said SYSTEM ADMIN

And today I learn that Rust does not like recursive functions :-(

(In user space, I’m recursive function happy!)

@acmel @ljs I was thinking of shimmy()

Continuing my Rust Rants :-)

It’s unfortunate that move is a keyword. As I write my little programs, I found that that’s a common function name I use. Now I need to come up with something else. adjust ?

@mripard also, this is really the exception and not the norm. I find saving these programs in subversion (svn) is more convenient than git. It's best with a central repository than trying to keep several machines in sync.

@mripard I totally agree, and why I've been an advocate. But I like to write these small programs, sometimes to just learn and sometimes to do a small job. All these are mostly throwaway code (but I keep for reference). In this case C/make is so much more convenient than Rust/cargo.

There’s gotta be a better way…

use std::env;
use std::path::Path;

fn usage(arg: &String) {
    let path = Path::new(arg);

    println!("usage: {} a b", path.file_name().unwrap().to_str().unwrap());
}

fn main() {
    let args = env::args();

    if args.len() < 3 {
        usage(&args.collect::<Vec<String>>()[0]);
    }
}

@mripard Yes, I found that. But you still have the extra step of creating the directory structure. It’s possible, but still annoying and not as trivial as C. But I guess that should be the tagline for Rust. Not as trivial as C

@mripard Yeah, I found that. Still not as easy as just creating a bunch of C files, and typing make foo and if will compile foo.c

Using the holiday break to learn Rust, I'm getting frustrated with Cargo. I mean, with C, I have a bunch of small programs that I use. But it seems that with Rust, to do the same, I have to make each one into a separate project, which I find overkill. Is there a easy way to make 100 little programs without making a 100 little projects???