A Couple of Questions Regarding Ruby Style

While working on my rational class I came up with a couple of questions
regarding the accepted way to do things. I looked up a couple of Style
guides on the net but they seemed to cover only the formatting of code
and not what I was looking for.
The first is when casting is it preferred to use Integer(x) or x.to_i?
Being from a C background the first is more obvious to me as it states
that I am converting x to an Integer. The second has its place when
chaining several changes to a variable but I can’t see it as being
clearer.
The second involves the initialization method for a class. I am making
it so that the .new method will accept Integers, Floats, Strings, and
Rational numbers. Should I be doing this, or should I require that all
the converting be done before calling new? If I allow any type of
Numeric, or String representation, is it acceptable to have the method
call other methods for some of the conversions?
I am learning a lot about Ruby in this project, and it seems that I am
constantly finding new things to add to it, and would like to code it in
the accepted style.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Michael W. Ryder wrote:

| The first is when casting is it preferred to use Integer(x) or x.to_i?
| Being from a C background the first is more obvious to me as it states
| that I am converting x to an Integer. The second has its place when
| chaining several changes to a variable but I can’t see it as being
clearer.

#to_i should be preferred. It’s way more commonly used in Ruby code than
Integer(x), and it is, IMO, more readable: ‘x to integer’.

| The second involves the initialization method for a class. I am making
| it so that the .new method will accept Integers, Floats, Strings, and
| Rational numbers. Should I be doing this, or should I require that all
| the converting be done before calling new?

Depends. If it is a class that isn’t exposed, you should convert before
you initialize the class. Otherwise, handle the conversion yourself.
That’s how I’d approach it.

| If I allow any type of
| Numeric, or String representation, is it acceptable to have the method
| call other methods for some of the conversions?

Yes.

| I am learning a lot about Ruby in this project, and it seems that I am
| constantly finding new things to add to it, and would like to code it in
| the accepted style.

The most accepted style is the style you are comfortable with. Sooner or
later, you’ll join the Dark Side^H^H^H^H^H^H^H^H^HRuby way of things, by
reading code, etc.

Which will help with finding out what the general style is, too. Read
code, and look at how others do things. :slight_smile:

And welcome to Ruby.


Phillip G.
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

Zmodem has bigger bits, softer blocks, and tighter ASCII.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgtGZIACgkQbtAgaoJTgL+7WgCeOe36QhHh0jt6T7J+Y78cO9j2
nKYAoJh2LXVBapZoAVuOmC4Emfu0xWwP
=psqh
-----END PGP SIGNATURE-----

Chris S. wrote:

I am really confused now! Integer(‘0xa’) = 10 but ‘0xa’.to_i = 0. So
it appears that “casting” using Integer(x) is preferable to x.to_i as it
will convert ‘valid’ numbers. I also noticed that x = .25 is not
allowed while x = Float(".25") or “.25”._to_f is.
The caveat about Integer(x) not handling ‘10 eggs’ I can live with as I
will ignore invalid data. The program currently converts strings to
Floats using Float(x) then converts Floats to two Integers for the
numerator and denominator. This allows the entry of Rational.new(“7.5”,
“.25”) to create a Rational number 30/1.

If it will make the life of someone using this library easier to pass
in Integers, Floats, Strings, or Rationals (and I suspect that it
will), I bet allowing it will be worth the effort. And it is
perfectly acceptable for the initialize method call other methods for
conversion or whatever you need when a new instance is created.

That will make it easier as I can create a method to handle strings and
expand it as I go. I was thinking of adding support for strings such as
“3/4” and then later when I figure out how to get the information for
the locale allowing “1,234.35”.
Thanks for clarifying these points. It looks like it is more important
to make sure that the function being used does what you expect rather
than what is most popular today.

On May 15, 10:52 pm, “Michael W. Ryder” [email protected]
wrote:

While working on my rational class I came up with a couple of questions
regarding the accepted way to do things. I looked up a couple of Style
guides on the net but they seemed to cover only the formatting of code
and not what I was looking for.
The first is when casting is it preferred to use Integer(x) or x.to_i?
Being from a C background the first is more obvious to me as it states
that I am converting x to an Integer. The second has its place when
chaining several changes to a variable but I can’t see it as being clearer.

It depends, mostly, on how loose you want to be. For example, when
dealing with strings, Integer only takes strings that represent an
integer value. So Integer(‘10’), Integer(‘0xA’), and Integer(‘012’)
all work fine (and happen to represent the same value). However,
strings that don’t JUST represent an integer raise an ArgumentError.
Integer(‘10.0’) and Integer(‘10 eggs’) fail.

String#to_i is much freer with what you can do. ‘10 eggs’.to_i gives
you 10, as does ‘10.1’.to_i. (Though, be aware that ‘10’.to_i !=
‘0xA’.to_i)

Choosing between the two is simply a matter of deciding which behavior
is more desirable.

The second involves the initialization method for a class. I am making
it so that the .new method will accept Integers, Floats, Strings, and
Rational numbers. Should I be doing this, or should I require that all
the converting be done before calling new? If I allow any type of
Numeric, or String representation, is it acceptable to have the method
call other methods for some of the conversions?

If it will make the life of someone using this library easier to pass
in Integers, Floats, Strings, or Rationals (and I suspect that it
will), I bet allowing it will be worth the effort. And it is
perfectly acceptable for the initialize method call other methods for
conversion or whatever you need when a new instance is created.

HTH,
Chris

On May 16, 2008, at 3:50 PM, Michael W. Ryder wrote:

I also noticed that x = .25 is not allowed

Float literals must have digits to the left of
the decimal to avoid ambiguity with method calls:

x = 0.25

Gary W.

Gary W. wrote:

On May 16, 2008, at 3:50 PM, Michael W. Ryder wrote:

I also noticed that x = .25 is not allowed

Float literals must have digits to the left of
the decimal to avoid ambiguity with method calls:

x = 0.25

That I figured out a while ago. My comment was that x = .25 is not
allowed but x = “.25”.to_f or x = Float(".25") is. Many older languages
allow x=.25 so having to place the leading zero is a sticking point as I
am still not used to having to use it.
My main point was the “inconsistency” of a couple of methods that I
thought were synonyms for each other. This is a real problem for me as
I keep having to experiment to find the correct method and usage for the
desired results. It took me a while to figure out how to get my coerce
method to return Rational numbers rather than Floats. The examples in
Pickaxe and in the rational.rb library all returned Floats. I finally
figured out that rather than calling x.coerce(self) I had to call
self.coerce(x). A simple change, like using Integer(x) rather than
x.to_i for converting to Integers to avoid a problem with “0xa”
returning 0 rather than the expected 10.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs