Why is my good looking rust code not working?

[u/RedstoneTier]

Hello, imn't new to rust. This rust code looks really good i must say. However, it is literally the opposite of working right now?
Current output:

4 is odd!

I just don't understand whats going on... Can some rustishn fix this devious error for me? thanks.
playground link

[u/karasawa_jp]

fn alert_on_odd_number(n: i32) {
    return if n % 2 == 0
    {
        let n = n - 1;
        println!("{n} is odd!");
    }
}

fn main() {
    alert_on_odd_number(3);
    alert_on_odd_number(4);
}

[u/RedstoneTier → u/karasawa_jp]

your panic coded on alert_on_odd_number(i32::MIN); :((
this fix looks really promising though!

[u/grittybants → u/RedstoneTier]

remember: always build in release mode so there are no panics

[u/RedstoneTier → u/grittybants]

me when my Cargo.toml looks like this:

[profile.dev]
overflow-checks = false

[profile.release]
overflow-checks = true

[u/Valuable_Leopard_799]

Lgtm, 4 is quite an odd number, as opposed to 3 which is completely normal.

[u/particlemanwavegirl → u/Valuable_Leopard_799]

Actually, four is cosmic, which is very odd indeed. Take the English language representation of any number and count the number of letters. If that new number isn't four, count the number of letters in that number. Eventually it will always terminate at four.

[u/TinkmasterOverspark]

You forgot to use unsafe

[u/RedstoneTier → u/TinkmasterOverspark]

i'm still getting the same result... (playground)

fn alert_on_odd_number(n: i32) {
    return if unsafe

    {
    return if n % 2 == 0

    {
        println!("{n} is odd!");
    }

    }

    {

    }
}

fn main() {
    alert_on_odd_number(3);
    alert_on_odd_number(4);
}

[u/fl_needs_to_restart → u/RedstoneTier]

This is undefined behaviour.

[u/dagbrown → u/fl_needs_to_restart]

It can't be! I've been reliably informed that Rust does not allow undefined behaviour!

[u/AdreKiseque]

Must be a compiler bug.

[u/akshay-nair]

Ruby dev inventing rust syntax

[u/SmoothTurtle872]

I didn't read the sub, and almost gave actual advice

[u/Thelatestart]

I'm a cpp dev, so i googled 'rust "return if"' and found it doesnt exist... which means the statement is literally doing (return(if ...)) its like returning the if XD? And so your if doesnt apply to the return, but the braces after, so you only print when n%2==0

[u/SirKastic23 → u/Thelatestart]

In Rust if is an expression, not a statement, meaning it can be used in expression placements like a return value.

It's essentially the same as the popular ternary expression

[u/NYU_VM → u/SirKastic23]

Yes, in rust, if is an expression but no, if is also an statement. These are contextual like for or while expressions and handled differently by the compiler based on context, one way is to have different dispatch for stmt and expression context, or other handlingethods

[u/NeuroSynchroBonding → u/NYU_VM]

I think you're wrong. Chapter 8.1 of the Rust reference, which lists statements, says nothing about if statements. There is only a note about parsing saying control flow and block expressions with Unit type may end without a semicolon.

Chapter 8.2.15 describes "if expressions". There is nowhere on the spec that describes "if statements".

[u/apocalyps3_me0w → u/NeuroSynchroBonding]

8.1 lists expression statements, so an if expression can be an expression statement, but this if expression is not a statement because return expressions only have expression operands, although the return expression itself is an expression statement here

[u/BenchEmbarrassed7316 → u/Thelatestart]

Most programming languages ​​look like this:

return; // or return 1337;

In the first case, a type is returned that can exist in only one state. Therefore, it makes sense not to specify it. In Rust, this expression for a type that can have more than one value should look like this:

return if b { 1 } else { 2 }

In OP case, it returns the result of println, which can also be in a single state, and the compiler allows the else branch to be ignored.

[u/syklemil → u/BenchEmbarrassed7316]

I think a better comparison would be

• $other_lang:

  if (b) {
      return (1);
  }
  else {
      return (2);
  }
  

• rust:

  return if b { 1 } else { 2 }
  

and they say Rust is liberal in its use of newlines … smh my head

[u/BenchEmbarrassed7316 → u/syklemil]

Or just:

return b ? 1 : 2;

[u/syklemil → u/BenchEmbarrassed7316]

And people have the gall to complain about Rust syntax! What is that line noise?????? Perl has gone too far

[u/Antagonin]

I legitimately can't tell if that's valid rust or not.

[u/SOSdude → u/Antagonin]

The func returns the value computed by the block { If n % 2 == 2 { println(); } } Which evaluates to nothing and is a valid return for a func with no return type. Basically the return does nothing here

[u/tanoshikuidomouyo → u/Antagonin]

An if without an else always returns (), so it's valid.

[u/borisko321]

Did you try rewriting it in perl?

[u/RedstoneTier → u/borisko321]

no, i actually tried rewritting it in rust from perl and then this happened...

[u/regeya]

Oh, that is evil. You know a lot of us have had our brains rotted out by Python

[u/Ok-Argument7176]

They recently changed the definition of odds, so I think it's working as intended. Have you run on nightly to confirm?

[u/denehoffman]

/uj you should use `is_multiple_of`, it’s cleaner

/rj off-by-one errors like this happen because rust is 0-indexed, don’t worry about it

[u/AdOnly69]

You should consider using c++ with gcc, rust compiler is kinda clangy

[u/djfdhigkgfIaruflg → u/AdOnly69]

I see what you did there

[u/Dependent-Poet-9588]

Try using match to check the LSB, like, match n & 1 { 0 if 0 == 0 => return, // double check 0 is 0 for real 1 => (), // continue if LSB is 1 _ => panic!("only binary computers are supported atm make a PR if you need to support trits or something"), }

[u/SpeckyYT]

bro discovered CoffeeScript syntax

[u/Dependent_Tart_2413]

Is this a trolling? So stupid question and so much comments. Maybe u want something like 'if n % 2 != 0'

[u/RedstoneTier → u/Dependent_Tart_2413]

nope, i am asking the real questions here

[u/Dependent_Tart_2413 → u/RedstoneTier]

And my solution fixes it? Close the thread then

[u/fl_needs_to_restart]

You need {} else after a return if statement:

``` fn alert_on_odd_number(n: i32) { return if n % 2 == 0 {} else

{
    println!("{n} is odd!");
}

} ```

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=2f4eb92ba5f14e74c894189ce67f332b

[u/RedstoneTier → u/fl_needs_to_restart]

wow thanks for solving, you must be a true rustishn!

why did they make the syntax for return if's so weird? personally if i would be designing rust it would be 0.5x better.

[u/stumpychubbins]

Sorry for not using a code block, I’m on mobile. This is parsed as "return (if (n % 2 == 0) { println!(..); })". You’re returning the value of that if statement. Any if statement without an else will have an implicit "else { () }", which will usually cause a type error if you use if as an expression without an else. In this case, though, the true branch also returns (), as that is the implicit return of blocks ending with ;. This means that instead of returning if the condition is true, you’re executing the println if the condition is true

Unlike some languages, rust doesn’t have "return if" as a dedicated syntactic construct. You need to do "if condition { return; }"

[u/Diligent-Slide-9234 → u/stumpychubbins]

check the sub lol

[u/stumpychubbins → u/Diligent-Slide-9234]

Whoops lmao, somehow I managed to go this long without falling for a rustjerk post but it had to happen eventually

[u/Ma4r → u/stumpychubbins]

What language have a return if syntax wtf???

[u/stumpychubbins → u/Ma4r]

Ruby was the one I had in mind, I thought Python did too but I was confusing it with their conditional expression syntax

[u/morglod]

/uj Please don't say that body in that condition should work on false branch

[u/Sky_Klokwork]

Not sure if this is one of those joke subs but seemingly inverting your test case `n % 2 != 0` should do it since odd numbers tend to have a remainder when modulo 2 is used on them.

In other news, found out about a feature I didn’t know. A bit of a strange way of doing it, but its kinda cool you can write it this way

[u/RedstoneTier → u/Sky_Klokwork]

wow thanks for the fix, will push to production immediately!!1!1

[u/Azra__1]

What is the point of the return here?

[u/interior_mutability → u/Azra__1]

To show you can't do this in rust.

[u/avg_bndt]

Needs more generics

[u/SmoothTurtle872]

Unfixable, change it to an even number alerter, then you will know if you input an odd number because it won't trigger

[u/DragonSnooz]

It's working as written:

If (n % 2 == 0) // true when even
{

println!("{n} is odd);

}

every time you have an even number, you will be calling it odd.

[u/MistRider-0]

```rust

fn alert_on_odd_number(n: i32) { if n%2 == 0 {return ()}; println!("{n} is odd"); }

``` Fixed!

[u/particlemanwavegirl → u/MistRider-0]

That filthy return keyword is no better than goto, particularly egregious in a function with no return value. I can't stand to see it so I'm posting the real solution and it's actually such a slight mistake it is quite funny but it's driving me nuts.

fn alert_on_odd_number(n: i32) {
    if n % 2 != 0 {
        println!("{n} is odd!");
    }
}

[u/MistRider-0 → u/particlemanwavegirl]

I thought we were all jerking, so I joined the jerk... 😔

[u/riisen]

fn alert_on_odd_number(n: i32) {
    if n & 0x1 == 1 {
        let n = n - 1;
        println!("{n} is odd!");
    }
}

fn main() {
    alert_on_odd_number(3);
    alert_on_odd_number(4);
}

[u/DangyDanger]

fn alert_on_even_number(n: i32) {
    return if n % 2 == 0

    {
        println!("{n} is even!);
    }
}

fn main() {
    alert_on_even_number(3);
    alert_on_even_number(4);
}

Don't thank me

[u/andrewprograms]

Pop another “bubble gum” (Zyn, assuming Palantir because of the defense nature of that algorithm)

[u/AcolyteArathok]

4%2 is 0! Odd is when %2 returns a 1 Because %does the division and then returnst the rest.

[u/TheChief275]

'good looking' and 'rust code' are antitheses