if err != nil {
return fmt.Errorf("oopsie wopsie: %w", err);
}


do Gotards really?

It wasn't too long ago that /g/tards wanted NO error handling structures because Unix style integer codes are good enough. You showed them a Result enum and they called you a tranny, guaranteed. Now look where we stand.

>>105968378 (OP)
gojeets are subhuman

>>105968378 (OP)
>no!!! i don't want to handle my errors!!!! I want the runtime to shit out a stacktrace every time i make a grammatical error!!!1!

>computer, create an error, let it rise up to the top level of call stack, and print a call stack as a message
>throw new Exception()
literally 22th century technology

try catch my balls tranny

>grab my balls
>grab my balls

>>105969054
>error codes
Kek. Reminds me when normgroids would ask me why windows update fails with some useless HRESULT that is also impenetrable to Google for some weird reason. Hell I can't even understand why you can find the first 500 win32 ones, but never for the other facilities.

An error code without a trace is completely worthless. At least go toddlers have those I guess.

>>105969103
You never do handle them though, go tranny. At least in modern languages you can pattern match exhaustively on all error variants.

>>105970030
>You never do handle them though
Speak for yourself, faggot.

Go makes faggots seethe because it's a language by the white man for the Indian man and it increases Indian software quality. Go is real Brahmins shit and has depreciated Java and Cshart.

>>105970030
>Pattern matching
Hello fellow Rust Neo-sister! :D

>>105970044
I know for a fact you don't. I've seen go programs, I've written go programs. The experience is objectively as bad, if not worse, than exceptions in oojeet languages. At least an exception requires you to actually catch it in a block. Still shit for exhaustiveness.

>>105970070
Post code

>>105968378 (OP)
if err != nil {
vs
if err {

>>105970070
>muh exhaustiveness
match func() {
Ok => val,
Err => err,
}


is exactly the same as
if err != nil {
return val, err
}

>>105970132
You're literally retarded if you believe this. Show me you handling something like opening a file and dealing with enoent in both dipshit, then repost.

>>105970182
let file = match File::open(filename) {
Ok => file,
Err(err) if error.kind() == ErrorKind::NotFound => {
// handle file not exist
},
Err(err) => {
// handle other errors
}
}


file, err := os.Open(filename)
if errors.Is(err, os.ErrNotExist) {
// handle file not exist
} else if err != nil {
// handle other errors
}


They're the same fucking thing with very slightly different syntax.

>>105970239
They aren't even remotely the same.
I swear to Christ. Go trannies are insane.
One is compiler enforced and discoverable from the type of the error, the other isn't and actually has to O(n) walk the errors and you better hope you picked the write package level error constant. Also now add eperm dipshit. One extra match arm, yours is a disaster. This doesn't even cover monadic handling of errors.

>>105970340
>Gets rekt
>Seethes over semantics
>Outs himself as a functional retard
>Refuses to post code
You have humiliated yourself my friend.

>>105970351
No, you have. It's pathetic how without fail, go toddlers demonstrate a complete lack of understanding of PLT. It's a midwit language and your post and code proves it.

>>105970351
Also guess what dipshit? Your code doesn't even close the file because gotoddlers don't have RAII. Again, it isn't the same. You don't know what you're doing or talking about.

>>105970239
Except Rust has heaps of syntactic sugar to make it convenient, Go has none at all because it's designed to be idiot-proof and idiots don't like abstractions.

>>105970030
exhaustive pattern matching is the most useless programming invention
and the reason why it's exhaustive is simply because it's expression so it must return something. it's byproduct of shitty FP design, nothing more

>>105970458
i love how c# handles it. it just throws exception if there is no matches.

>>105970458
>being able to ignore errors is actually, le bad.
why do you retards even pretend to like a type system if you won't use it? Why do you guys tout a system that's worse than exceptions like it's some breath of fresh air?

>>105970458
Exhaustive matching is perfectly fine, but even when you don't need it, Rust has if-let and while-let constructs.

Alongside Erlang, Golang is the whitest language to date.

>>105970684
erlang is for white people (aryan chads)
go is for white people (effeminate liberal faggots)

>>105970684
That's probably why it's shit. It's made for nepobabby midwits. Chinese century, whittu piggu. Cope.

void* important_ptr = do_something();
assert(important_ptr != NULL);

>>105970340
>~43% more symbols for the same result
Enjoy your bloated let me hold your hand language.
Also consider joining the 43%

>>105970729
>Compiler assumes pointer can never be NULL and deletes your assert
Heh, nothin personnel, kiddo.

>>105970743
It's not the same code nor does it do the same thing.
EINVAL

>>105970016
> HRESULT is bad, I need it to drop into my source level debugger for every error
Usually you don’t have the source code for every windows program.
I can tell you’re very new to working with computers, but most (if not all) of them are written in C. Look into it.

>>105970743
>gotard complaining about more typing
you can't make this shit up
also see >>105970505

>>105970793
What the fuck are you talking about retard? The point is even normie centric shit like Windows Update forwards deep error hresults with zero context to users. Error codes tend to do that. With exceptions, at least you get a backtrace to go with it. Nothing stops you from having a backtrace of codes too.

>usually you don't have the source code
Sounds like a wincuck problem and all M$ shit has a symbol server anyway so you
a) can't read
b) don't even know windows or debugging in windows

>>105968378 (OP)
Posted it again award

>>105970375
>>105970413
Seething same fag. Post code or keep coping.

>>105970758
That is the sensible thing to do. Asserts are declarative about program state; they are not for doing error handling. When you use an assertion you are telling the compiler a Truth.

>>105970758
Not my problem, my game code does not really do error handling except for cases where the user could do something stupid. I spam asserts everywhere and fix all errors I can find when developing, as that's what asserts are for.

>>105970413
If the lifetime of the data is the same as the application there is no need to manually clean it up, the os will mark all the pages to be reused. In fact this is memory safe as proved by Rust because parts of Rust's stdlib just lets the os clean up shit after it's done making a mess and leaks memory if that shit is expected to life the entire life of the program. Don't believe me? Start valgriding your Rust code.

>>105970854
My C programs explain what's wrong and which line in the source the error is on, you're simply full of shit.

>>105971004
I was making a joke, but that's just a harrowing comment...

>>105970684
>Brian Kernighan
the eternal intern

>>105970061
rust > java >= c++ > c# >>>>>>>>> gojeet

>>105970351
ok saar
dont forget to redeem if err != nil saaaaaaar

>>105970684
go is brahmin tier language saaaaar *braaaaaaaap*