Don’t know if I misunderstand you, but you can simply do this in F#:

match Int32.TryParse(xxx), Int32.TryParse(yyy) with
| (true, foo), (true, bar) -> (* something *)
| _ -> (* otherwise *)

Anyone still not agreeing with Kurt?

Btw, a real F#-ish TryParse would return an option value, with which it could look like this:

match Int32.TryParse xxx, Int32.TryParse yyy with
| Some foo, Some bar -> (* something *)
| _ -> (* otherwise *)

if first && second then (* dothomething with first and second *) else (* default behaviour *)

Pretty cool. Even cooler would be some kind of active pattern.

match (xxx, yyy) with
| (parse(first), parse(second)) -> (* dothomething with first and second *)
| _ -> (* default behaviour *)

My point is you _can_ have “tupley” =) code in C#, it’s just called a “return type”. In the case of the dictionary example:

var result = myDictionary.TryGetValue(key);
if (result.IsValidKey)
{
…result.Value
}
Where “TryGetValue” is an extension method that returns a custom type.

Granted, you don’t get the language-baked feature to automatically do this, but with a few good extension methods, you wouldn’t miss it =)

However, it seems, in this case, that it would make more sense to have a bool Int32.CanParse(string value) method.

And, move the TryParse methods to a special System.ICryAboutPerformance namespace.

Just a thought.

It may be better to say what I am thinking. I was not aware of tuple’s either and F# does seem to have an elegant way of handling multiple return values.

string raw = “1234″;
int val; /* No need to initialize an out parameter */
bool success = int.TryParse(raw, out val);

compared to that :

let raw = “1234″
let success, val = Int32.TryParse(raw)

?

Let me even rewrite first snippet of code in C#3 :

var raw = “1234″;
int val; /* Too bad I cannot write declare val as var */
var success = int.TryParse(raw, out val);

As far as I can count, I have as many variable declarations.
Only differences are : semicolons, typed declaration(s) and order of declarations (val is declared before use in C#).

Maybe you’ll find this disturbing, maybe you’ll find that tuples rock, maybe you’ll find that TryParse design sucks, but don’t say this is because of verbosity.