let tryParseInt a =
match Int32.TryParse a with
| (false, _) -> None
| (true, x) -> Some x

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.