Comments on: Ruby is dynamically AND strongly typed

By: OJ

OJ — Tue, 10 Jul 2007 03:53:46 +0000

1.
x = call_function_that_returns_the_number_3_in_the_string_form;
2.
y = x + 1 //The programmer expect that “y” will equal 4 (Tee hee hee!)

Bad example. Noone in their right mind returns numerical values as strings from functions. If the function should return a number, then return a number, not a number as a string.

If in a particular case the programmer knew that the value was going to be a number contained in a string, then he/she would make sure that the value is cast to the right type before proceeding.

What can happen in a language, and what does happen when people are using the language are not always the same thing.

By: Mr Funk

Mr Funk — Tue, 10 Jul 2007 05:09:54 +0000

1.
x = “3″
2.
y = x + 3 #Wooo! Ruby won’t like that

Won’t y = “33″ ?

By: Mr Funk

Mr Funk — Tue, 10 Jul 2007 05:12:10 +0000

Hmmm it appears not

By: Shalev

Shalev — Tue, 10 Jul 2007 07:11:08 +0000

class Fixnum
alias_method :old_plus, :+
def new_plus(other)
return self.to_s + other if other.kind_of? String
self.old_plus(other)
end
alias_method :+, :new_plus
end

x = “3″
y = 3 + x # y now equals “33″

The fact is, that ruby is so dynamic (and I use the term not in its official context) in nature, that strong typing loses much of its punch. Granted, the default operators will act in a strongly typed manner, but if you took the time to override these operators on the basic primitives (which are really objects/classes), you’d end up with something that looked pretty weakly typed.

It’s the best of both worlds, from a coders standpoint.

By: Shadowfiend

Shadowfiend — Tue, 10 Jul 2007 15:25:32 +0000

Strong vs weak typing is a very strange and opinion-based argument. There’s no real one definition of strong vs weak typing, except that I think most people agree C is weakly typed. For example, you bring up Javascript. Javascript isn’t necessarily weakly typed, it just has certain coercion rules so that in certain contexts certain types will be converted to others for compatibility purposes.

To be honest, I think in Ruby, as Shalev pointed out, strong vs weak typing isn’t particularly important because of the dynamic nature of the language.

By: yriafelc

yriafelc — Thu, 12 Jul 2007 13:10:36 +0000

x = ‘3′
x = x + 3 # Error!

but:

Class Fixnum
def to_str
self.to_s
end
end

x = ‘3′
x = x + 3 # x = ‘33′

By: Stephan Schmidt

Stephan Schmidt — Fri, 13 Jul 2007 08:27:25 +0000

Most of those discussions are wrong.

The key concept to grasp in strong versus weak typing is that there is a distinction between reference typing and object typing. Java has static typed references and static typed objects.

Person me = new Person(”me”)

Both the reference and the object are static typed. People usually call this strong typing.

me = Person.new

Here the reference is dynamic typed and the object is static typed (although in Ruby objects can change their appearance during run-time). Dynamic typed references with static typed objects people usually call weakly typed.

Groovy is makes the distinction more difficult. It support both dynamic and static references, just as needed.

def me = new Person(”me”)

and

Person me = new Person(”me”)

are both legal Groovy code. The first with dynamic typed references and the second with a static typed reference.

I’ve written extensivly about the distinction more than a year ago.

Peace
-stephan

–
Stephan Schmidt :: stephan@reposita.org
Reposita Open Source - Monitor your software development
http://www.reposita.org
Blog at http://stephan.reposita.org - No signal. No noise.

By: jman

jman — Fri, 13 Jul 2007 12:54:59 +0000

Excellent explanation of a easily misunderstood concept!

By: Shadowfiend

Shadowfiend — Fri, 13 Jul 2007 13:59:17 +0000

@yriafelc — yes, but in that situation, you’ve changed the `unmentioned’ semantics of +to_str+ — namely, that an object that has that method is, for all intents and purposes, a string, while +to_s+ means that it can be represented as one. Personally, I think String#+ should use +to_s+ rather than +to_str+. But then again, that’s what string interpolation is for, so whatever.

By: Matt Giuca

Matt Giuca — Fri, 13 Jul 2007 16:35:16 +0000

So from some of these comments (the guy who overloaded Ruby + and the guy who said C is weakly typed) - it seems like we can classify strong/weak as being a property of the OPERATORS themselves, not the type system! (For the most part).

I wouldn’t classify C as having a particularly weak type system. It lets you implicitly cast numbers around (eg. (int)3 + (float)4.7 => (float)7.7), but that’s about it. For instance, C won’t let you go “3″ + 4 and give you 7 - which a truly “weak” type system will give you.

Oh no, C is far worse - it isn’t _weak_, it’s _unsafe_! The 3rd classification after dynamic/static and weak/strong is safe/unsafe. In C if you do “3″ + 4, you get … a pointer 3 bytes past the end of the string! This is usually unacceptable in modern languages so it doesn’t happen in most. But just a point, I wouldn’t consider that “weakness”.

Sorry for getting off-topic. Oh, a very good article though!

By: Shadowfiend

Shadowfiend — Sat, 14 Jul 2007 23:34:41 +0000

But that’s often what’s meant with weak. Weak means that there is a weak distinction between the types (more or less). In C, that’s particularly evident because you get virtually no distinction between pointer types — they’re all integers at the end of the day, and you can do whatever you want with them. Casting lets you achieve just about anything, with no checking until you get a segfault in your running program

By: txt » Dynamic/Static/Strong/Weak Types

txt » Dynamic/Static/Strong/Weak Types — Wed, 25 Jul 2007 18:16:17 +0000

[…] Original Article […]