Musings

[andrewducker]

I've been coming to the conclusion that I don't like the way that methods return variables in C-like languages.  Having a single prioritised output parameter seems counterintuitive to me, and leads to two outcomes:
1) It's very easy to ignore/forget the return value.
2) If you have multiple return values then either one of them is the "proper" return value and the other one is passed back as a reference, or you pass back a tuple of some kind, or you have no return value and they both come back as references. 

It seems to me that it would be clearer and simpler if you always specified what parameters were in and out.

Rather than
string Reverse(string inputString)
you'd have
Reverse (string inputString, out string outputString)

This doesn't make a lot of difference when it comes to a simple method like that.  But if we take one with two outputs:

Do we use:
1) int GetMonthAndDay(DateTime inputDate, out int day)
2) MonthDayPair GetMonthAndDay(DateTime inputDate)
3) void GetMonthAndDay(DateTime inputDate, out int month, out int day)

The first one is clearly awful, the second one requires me to create an extra class, and the third one seems entirely clear.

Also, the use of different parameters means that you have smart method selection going on.
Convert(DateTime inputDate, out long seconds)
Convert(DateTime inputDate, out string nicelyFormatted)
makes it obvious from the parameters exactly what you're expecting to get back from it.

Of course, it does complicate very simple things:
DateTime tomorrow = today.AddDay();
would become
DateTime tomorrow;
today.AddDay(out tomorrow);

I suspect I'm just working on stuff where there are always multiple ins and outs, and also using generics and type inference, which doesn't work on return values, just parameters, and this is leading me to odd conclusions.

Comments

[andrewducker]

Oh, absolutely. It's not going to work for functional languages.

[figg.livejournal.com]

Um, no, It works quite well for prolog.

The problem is that function composition is a bitch
instead of doing


y = f(g(x)), you have to do f(x,x1), g(x1,y)

this gets very clumsy and annoying after a while.

Functions are useful for the common case of a single return, and in more mature languages you can return multiple values as pairs.

[andrewducker]

Aaah - I thought it would be even more ungainly than that. But then it's been a very long time since I played with Prolog.

Is there a nice way of returning pairs of values? Or do you just get back a class with two things in it, and have to hope that they're the right way round?

[figg.livejournal.com]

Prolog isn't object orientated, and abstract datastructures are a piece of piss.


To be frank, I haven't encounted such a problem with python, named parameters and easy tuples make this sort of problem a breeze.

Oh, and you're confusing strict and strong typing. Strict typing is type definition at compile time, and dynamic is at runtime.

Strong typing is the lack of implicit casts, and weak typing has implicit casting.


Oh, and saying 'hey intellisense makes this easy' is akin to 'hey this crutch makes it easy to walk with a broken leg'.

[andrewducker]

I didn't mean from Prolog. I meant from something that is object oriented. How does Python do it?

You're right about the casting - I meant static analysis, which is the "strict" side of things.

I don't understand your problem with intellisense. Care to elucidate?

[martling.livejournal.com]

Tuples are part of the core type system in Python. You don't have to declare a class to hold your tuple, you can just return "foo", 3. The same is true of most functional languages, e.g. (string, int) is a valid type in ML.

It's a shame this is missing from Java, it seems it was planned originally: http://gbracha.blogspot.com/2007/02/tuples.html

I gather that adding this to C# would be difficult now because essentially the CLR type system doesn't have the underlying support. F# has tuples in the language but the underlying implementation is a hack.

Incidentally, has figg told you about the gathering he is organising for people interested in programming languages?

[andrewducker]

Just looked a Python example to see how it picks it up, and I have to say I don't like it much - largely because everything we do here is statically typed, with nice names attached to it. Losing that doesn't seem worthwhile.

[martling.livejournal.com]

Oh, sure, it's still Python and therefore a non-confidence-inspiring dynamically typed mess. But the basic principle of tuples as a core part of the type system could be added to to any language - it's just sadly pretty rare outside of functional languages.

If you had them in a statically typed C-like language you could do this:

(int month, int day) GetMonthAndDay(DateTime inputDate) {
    return (inputDate.getMonth(), inputDate.getDay());
}

And then call like this:

(int month, int day) = GetMonthAndDay(date);

Note that as first-class types, tuples would also be usable for input parameters, variables, etc.

(int month, int day) month_and_day;
month_and_day = GetMonthAndDay(date);
int day = month_and_day[1]; // address like arrays.
int month = month_and_day.month; // or like structs, if contents named
 birthdays = GetBirthdays(month_and_day);

[andrewducker]

Which makes them basically methodless classes - except that you can only access the items in them by order, not by name.

To put it mildly - ick!

[martling.livejournal.com]

I don't see any reason why the tuple members couldn't be accessed by name, if names were given for them where the tuple was declared. I suggested this in the the penultimate line above.

The function in that style:

(int month, int day) GetMonthAndDay(DateTime inputDate) {
    return (month = inputDate.getMonth(), day = inputDate.getDay());
}

I'd think of them rather as anonymous C-style structures than as classes - there's nothing specifically object-oriented here.

[andrewducker]

Aaah, sorry. No brain today (dashing in circles fixing things).

That's more useful, definitely. And would do what I want.

Sold!

Now, someone needs to get on the phone to the C# boys and tell them that their anonymous classes need to work better so that they can be used this way!