[ruby-core:98401] [Ruby master Feature#16894] Integer division for Ruby 3

Issue #16894 has been updated by jzakiya (Jabari Zakiya).


The following is meant to be an objective assessment of the proposal, taking no stand on approval, or not.

The proposal is for inclusion of the "feature" in **Ruby 3** . By definition, Ruby 3 will be a major version, which will incorporate new features, while trying not to break (too much) prior code. Anyone upgrading will know they will have to modify existing code to use any of the new features. Similarly, any possible breaking changes (e.g. for ``/``, et al) will be psychologically less stressful on the whole, as it will be incorporated into the general upgrade process. I would imagine tools like ``Rubocop`` will evolve to incorporate these changes to assist people to upgrade.

Also, there will undoubtedly be a plethora of blogs, articles, and presentations on all the changes introduced by Ruby 3, so the aware user should not be caught flatfooted on what to look out for in the upgrade process. For a new user it wouldn't matter at all, since whatever the syntax is that's the syntax they would just learn to use (no unlearning needed).

There are two (2) major components to the proposal:
1. should it occur, i.e. is there enough of a rational, et al, basis to make the change.
2. what should be the agreed upon syntax to represent the change.

1) This "feature" is now codified in syntax in various languages, e.g. Python, Crystal, Nim, Sidef, et al (I haven't done an extensive search for a complete list). One explicit purpose (especially for compiled languages like, Nim and Crystal) is to consistently/visually establish the expected result of division.

In a compiled language with explicit types, it's easier for writing the compiler to know if the two arguments are integers then ``//`` tells the compiler to produce another integer, while ``/`` says convert to float. The opposite if the arguments are float.

Also, the source code now becomes visually consistent and explicit for the code writer and its readers.

As a matter of preference, Ruby made the decision to base the result of division using ``/`` on the argument types, so the programmer still had to know the desired outcome and then use the appropriate syntax.

Thus for explicit numbers:   ``9 / 2 = 4``  and ``9 / 2.0 = 4.5``
But also then for variables which could be any type:  ``a.to_i / b.to_i = c`` (integer) and ``a / b.to_f = c`` (float)
Either way, you need to know the proper operational syntax to get the desired outcome.

2) As a matter of operation syntax, it's probably "best" to use familiar syntax for easier/wider adoptability (Crystal, Sidef, and Python use ``//`` while Nim uses ``div``), have it be short, and contexturally non-conflicting. 

I don't know how the usage of ``//`` exists in ``regexs``, but this question's answer is empirical, not subjective. Just do an entire code base check on the symbols ``/`` and ``//`` to produce a baseline profile of their use. I would guess their use is so specific as not to cause contextual parsing problems, especially since Ruby is rife with aliasing of symbols. Also, the use of ``/`` will occur most prominently in numerical heavy modules|code further specifying its use.

I hope this has been helpful.



----------------------------------------
Feature #16894: Integer division for Ruby 3
https://bugs.ruby-lang.org/issues/16894#change-85668

* Author: ankane (Andrew Kane)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
Hi Ruby team,

It'd be great if division in Ruby matched what we all learned in school.

``` ruby
1 / 2 == 0.5
```

New developers wouldn't immediately be confused when they try to do division and experienced developers could stop adding to_f to their code (typically after they get tripped up on the first run). In my experience, floating point division is way more common than floor division. This could definitely break existing code, so I understand it's a decision that shouldn't be made lightly. Overall, Ruby is really intuitive, but this is one place where it's not.

It looks like this was considered for Ruby 2.0 as well as few years ago in #5512, so feel free to close if it's not something you'd like to reconsider right now.

---Files--------------------------------
integer division.png (14.3 KB)


-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>