Return type hinting patch View as Markdown

Hello Sam,

I think you misunderstand, let me retype for you.

strlen('abstract protected function string dostuff()') < strlen('abstract
protected function dostuff() return string')

Making your argument on length void, also, maybe we should not base a
language change decision on typing extra characters..

Sorry man, but to me the code below looks so unusual for what it is meant to
represent:

abstract protected function bar($foo) return string {
// code
}

The above, actually kind of makes me think something non-conventional is
going to happen like return string specifies that it will be auto type
casted to a string for me or something. like:

abstract protected function bar($foo) return string {
return $foo;
// is auto magically like: return (string) $foo;
}

vs the below code that tells me function returns a string like in many
popular languages.
abstract protected function string bar($foo) {
return (string) $foo;
}

-Chris

I don't know, maybe it does work. But either way I'm not introducing a
new keyword, I changed the patch to reuse the return keyword.

Yes, long strings of keywords:

abstract protected string function dostuff()

On Fri, Apr 25, 2008 at 12:25 PM, Sam Barrow sam@sambarrow.com
wrote:

    > On Fri, Apr 25, 2008 at 1:15 PM, Sam Barrow
    <sam@sambarrow.com> wrote:
    >         On Fri, 2008-04-25 at 14:08 -0500, Jeremy Privett
    wrote:
    >         > Sam Barrow wrote:
    >         > > I figured it out, the syntax is now as follows:
    >         > >
    >         > > function a($b, $c) returns d {
    >         > > }
    >         > >
    >         > > I'll post an update soon.
    >         > >
    >         > >
    >         > >
    >         >
    >         > That's certainly a non-intuitive syntax. How about
    we take a
    >         page out of
    >         > the book of other C-style languages before trying
    to invent
    >         something
    >         > else? I agree with Stas, "return" and "returns"
    are not part
    >         of a
    >         > function definition.
    >
    >
    >         I don't think it's non-intuitive at all, and even
    so, it's the
    >         most intuitive we have. This ordering makes more
    sense to me
    >         at first glance (in the order I would think about
    things;
    >         scope, name, arguments, return).
    >
    > im not sure the following has been explicitly proposed, but
    how about
    > omitting the 'return' keyword and placing the return type
    hint before
    > the function identifier
    >
    > function int a($b, $c) {}
    >


    This is, but I don't think this is possible, due to confusion
    with the
    keywords (public, private, static, abstract, etc). Plus this
    leads to
    long strings of keywords.

There can be no technical reason why this more adopted and understood
syntax should not be possible. Adding returns as a keyword would
completely break tons of code. Why are the proposals on something that
is so consistent across many languages being changed so obscurely? Why
a seperate non-intuitive syntax.

public function int (string $foo) { return 1; }

Can't we keep the sanity?

    [ ... ] Plus this leads to
    long strings of keywords.

Are you kidding? strlen('returns int') > strlen('int'); .....

-Chris

I like the first too, if this can be implemented I think it is a
suitable syntax.

public function int doThing(string $foo) { return 1; }

The above is the best (ie omit 'return' or 'returns').

This also is consistent with C and with the way that the manual is written, eg:

http://www.php.net/manual/en/function.strlen.php

The only argument is the relative ordering of the keywords.
We keep 'function' - since that is the way that the language works.
Things like 'public' we put before 'function' since that is the way that
it works in PHP 5 objects.

So the only thing to decide is where the type goes:

public function int doThing(string $foo) { return 1; }

or:

public int function doThing(string $foo) { return 1; }

I would favour the first one, this is probably also easier to parse, as
following 'function' and before '(' you can have:

• 1 word - which must be the name of the function
• 2 words - the first word is the return type, the second the function name.

If the function returns a reference to something of a particular type, where
does the '&' go:

public function &int doThing(string $foo) { return 1; }

or:

public function int& doThing(string $foo) { return 1; }

I would suggest the second, ie just before the function name.

--
Alain Williams
Linux Consultant - Mail systems, Web sites, Networking, Programmer, IT Lecturer.
+44 (0) 787 668 0256 http://www.phcomp.co.uk/
Parliament Hill Computers Ltd. Registration Information: http://www.phcomp.co.uk/contact.php
Chairman of UKUUG: http://www.ukuug.org/
#include <std_disclaimer.h

Wouldn't the most consistent way be to omit "function" altogether when
using a return type hint?

public static function zomg() {
return $somethingArbitrary;
}

public static string foo() {
return $mustBeString;
}

otoh, should there ever be a type "function" (e.g. for anonymous
funcs) down the road, that'd mean trouble ;)

David

Am 26.04.2008 um 01:13 schrieb Alain Williams:

public function int doThing(string $foo) { return 1; }

The above is the best (ie omit 'return' or 'returns').

This also is consistent with C and with the way that the manual is
written, eg:

http://www.php.net/manual/en/function.strlen.php

The only argument is the relative ordering of the keywords.
We keep 'function' - since that is the way that the language works.
Things like 'public' we put before 'function' since that is the way
that
it works in PHP 5 objects.

So the only thing to decide is where the type goes:

public function int doThing(string $foo) { return 1; }

or:

public int function doThing(string $foo) { return 1; }

I would favour the first one, this is probably also easier to parse,
as
following 'function' and before '(' you can have:

• 1 word - which must be the name of the function
• 2 words - the first word is the return type, the second the
  function name.

If the function returns a reference to something of a particular
type, where
does the '&' go:

public function &int doThing(string $foo) { return 1; }

or:

public function int& doThing(string $foo) { return 1; }

I would suggest the second, ie just before the function name.

--
Alain Williams
Linux Consultant - Mail systems, Web sites, Networking, Programmer,
IT Lecturer.
+44 (0) 787 668 0256 http://www.phcomp.co.uk/
Parliament Hill Computers Ltd. Registration Information: http://www.phcomp.co.uk/contact.php
Chairman of UKUUG: http://www.ukuug.org/
#include <std_disclaimer.h