I didn't say don't handle errors. I'm saying that you're offering a false idea of what's happening in Go's error handling.
package mainimport("fmt")func main(){ good, bad_or_otherwise := ret(); handle_error(bad_or_otherwise) fmt.Println(good)}func ret()(int, int){ return 1, 5 }func handle_error(input int){ fmt.Println("Error: ",input + 1) }
Erlang isn't bad and I've used it quite a bit. I never said it was bad. That being said I do believe that Go has a better balance of features.
racket is a better erlang than erlang is
was just wondering why that iferrnil stuff is everywhere in go code. most other languages dont have anything like that.
Yeah, it's a multiple return. You could really return any kind of var in that second place. It doesn't have to be an error. Doesn't just have to be two either. In something like C or the like, you can achieve something similar by returning an enum or struct. This is just syntactic sugar. Then again, anything beyond asm is just syntactic sugar if you look at it a certain way.
To expand on that, using it as error checking is just common usage. It's not enforced by the language's standards.
...
Miss me yet?
write some code to convince me
Courtesy of Damian Conway
# All the primes... constant p = [ (1..∞).grep(&is-prime) ]; # The definitions of "strong" and "weak"... sub strong (\n) { n > 0 && p[n] > p[n-1, n+1].sum/2 } sub weak (\n) { n > 0 && p[n] < p[n-1, n+1].sum/2 } # All the strong and weak primes... constant strong-p = p.kv.map: ->\n,\pₙ {pₙ if strong n}; constant weak-p = p.kv.map: ->\n,\pₙ {pₙ if weak n}; # Print out the first ten... say 'strong primes: ', strong-p[^10]; say 'weak primes: ', weak-p[^10]; say < Rust Go C C++ Java Python Haskell Ruby ATS >.join("Niggers BTFO\n");
Of course the retarded Gopher is from reddit.