Yeah, type inference would be an improvement, it's also not that big a deal.
If you're dealing with integers you can quite easily do
int fiftyFive = 7*5.
And operator overloading, unless you're specifically doing numeric computation, is usually a very bad idea. Makes you feel clever, and makes your code unmaintainable.
I've coded erlang, but not haskell. Like both syntaxes much better than java.
Ok, point ceded on integers, now what do I do if I want to use a positive integer in excess of 2^63?
2^63 seems like a weird cutoff to me for positive integers, but keep in mind that features like this are the "best of" java according to you. I bought a 64 bit chip, I'd like to use more than half it's integer range.
Bigger than that, you're out of the range of the primitives that they coded into the language, or into most languages for that matter, so you're going to use to use some library construct to handle multi-word numbers. That's one of the few cases where operator overloading might help you, but frankly if your program is primarily doing high-end numerics, you should probably be coding in C which is much less friendly on all counts.
I don't actually prescribe Java for web dev, strong-typed languages are generally bad for web dev and the lack of type inference and some other syntactical shortcuts make Java even more of a pain for that type of stuff. It got a lot better with 1.5 on a couple of the niceties, but if what you're doing maps better to a scripting language, use a scripting language.
As far as the philosophy goes.. as I've worked on more projects in my life I've learned to distrust everything clever. Sometimes Java can be a bit too restricting, and Scala seems to be an unabashed improvement in terms of promoting better programming practice, but super clever things like monkey-patching and operator overloading for the sake of brevity can be very unpredictable when you need to fix a bug in someone else's code and do it quickly.
Operator overloading can be used stupidly but then again so can just about any feature. Operator overloading is no more clever than method overloading.
Pipe Operator:
Seq.init 100 (fun x -> x*2)
|> Seq.reduce (+)
Creates a sequence of numbers from 1 to 100 multiplies them by two and then adds together.Composition operator:
let add x y = x+y
let mul x y = x*y
let addFiveMultiplyBy20 = add 5 >> mul 20
Define a class type User(firstName,lastName,email) =
property x.Name.get = x.firstName + x.lastName
I'm a little rusty on the class syntax so it might be off. Btw, the class that that would create would be fully generic with a requirement that the class of firstName and lastName have the (+) operator defined. So you could use the code: let user1 = new User("Foo","Bar","[email protected]")
let user2 = new User(42,24,new EmailAddress("[email protected]"))
As well you could do this: let (+) (x:string) (y:int) = x + y.ToString();
let (+) (x:int) (y:string) = x.ToString() + y;
let user3 = new User(42,"Bar","[email protected]");
Any language that forces me to write
Is not something I'd worry about the "best parts". I'll leave the whole language for enjoyment of programmers who are more "enterprise ready".