Comments on: Type hints are more useful for scalars than objects

By: Mike

Mike — Fri, 12 Sep 2008 09:10:14 +0000

One thing that (PHP-)developers tend to miss is that OOP is a lot about describing and strictly defining your architecture or class or function and not just about "let's pack some functions into a file and call it a class".

With a strictly defined code, you are able to just read and understand another developer's piece of code simply by looking at it. The other developer could also be you, revisiting your own code after months, weeks or just days.

And, more importantly, you can't break anything all too easily.

By: Alan Pinstein

Alan Pinstein — Thu, 11 Sep 2008 22:00:44 +0000

I was excited about type hinting when it first came out, but quickly abandoned using it.

The main problem I ran into was that you get a FATAL error if your argument doesn't match. This causes problems for applications that have highly dynamic runtimes and may at times generate the wrong objects. You can't easily catch the error since it's FATAL.

Instead, I do asserts at the top of my functions that throw exceptions if the improper data is passed.

By: dagfinn

dagfinn — Sun, 07 Sep 2008 21:55:26 +0000

As I said it’s a matter of judgment. It’s not black and white. Interfaces (in the syntactical sense) may be a necessity if you really want to use type hinting, but ideally an interface should express a meaningful abstraction, and that abstraction is not likely to be stable in the beginning. In that case, I’m inclined to say it’s better to avoid both the interface and the type hints rather than have an interface that’s just a technical trick. I suggest that type hinting may be more useful for a stable interface, and that’s just the kind of thing you will be seeking if you’re developing a framework. As for dependency, I said dependency on the class (or interface, I should have added) name. There is a dependendency if you don’t use a type hint, and it’s less specific, not just less explicit.

By: Koen

Koen — Sun, 07 Sep 2008 21:05:40 +0000

If you’re not using the interface/type hint you have the dependency also. The difference is that now it is not explicit.

By: Mathias

Mathias — Sun, 07 Sep 2008 18:12:21 +0000

My team is working on a framework, and we’re making more and more use of interfaces and type hinting. This way the method is basically saying: I don’t care what the class the object has, as long as it’s abiding by these rules. Although haven’t actually encountered a lot of bugs that could have been prevented by object type hinting, using it gives me a warm feeling of ‘less can go wrong’.

And yes, I don’t understand either why php doesn’t have native scalar hinting

By: Mike Lively

Mike Lively — Sun, 07 Sep 2008 16:36:11 +0000

I suppose to some extent you are right about limited usefulness but in my opinion the value of them is that it can

1. point you in the right direction alot sooner. Imagine you passed the wrong type of object but it just HAPPENS to have a function of the same name? That could be relatively annoying, capable of passing unit tests, and quite possible wouldn’t throw any errors. It would just result in strange behavior that may or may not be immediately apparent.

2. A call to a non-existing method is a fatal error. A call where the correct type is not passed in is a “catchable” fatal error. Now in practice this too probably doesn’t mean much, but it does provide for more opportunities to recover or alert people to what is going on.

Also, to address point 1. I think a mistake alot of people make is to not use interfaces as much. If you have a method call that expects a certain type of object that has say 10 public methods. If you only really need access to 2 of those methods then there is a very good chance that you are only trying to utilize one aspect of that class that could be segregated into an interface. This would make your code much more flexible while saving you from the potential headaches in my previous point.

That all being said, scalar type hints would also be nice if they were native .