Issue #12637 has been updated by r.smitala (Radovan Smitala).


matz (Yukihiro Matsumoto) wrote:
> Ruby is not Scheme.
> 
> The rule is simple: every bang method should have its non-bang version, which does not modify the receiver.
> That does not mean every non-bang method keeps its receiver unchanged.
> 
> Matz.

I know my reply could be annoying. I am apologise before.
After a year of using Ruby in mid-sized project we had some unlikely issues with mutating receiver. Because we are influenced by functional principle immutability of object we fixing interesting behaviour of our app caused by our infallibility that code we used doesn't change the state. As we figuring out we have forgot that some methods changing the receiver.

By our experience it is easier to remember uniform behaviour (immutable/mutable) for method calling than thinking about different behaviour for some methods without bang alternative.
we had no problem with remembering that Integer, Float, Nil, and Boolean is passed by value and everything else with reference. But method behaviour because we can't be sure that method without exclamation mark should return new value.

I also think migration to new method naming is really easy with simple regex replacing.

----------------------------------------
Feature #12637: Unified and consistent method naming for safe and dangerous methods
https://bugs.ruby-lang.org/issues/12637#change-66792

* Author: r.smitala (Radovan Smitala)
* Status: Rejected
* Priority: Normal
* Assignee: ruby-core
* Target version: 
----------------------------------------
Hello,

As a multi-paradign language allows programmers to code from imperative to functional style. This gives Ruby to be modern and wide used language in these days.
Ruby is built on idea to be as fun, understandable and focused for people.

But i think it carry "complicated behaviour" in some method naming.

In this documentation is written: (http://docs.ruby-lang.org/en/trunk/syntax/methods_rdoc.html)
> The bang methods (! at the end of method name) are called and executed just like any other method. However, by convention, a method with an exclamation point or bang is considered dangerous. In ruby core library the dangerous method implies that when a **method ends with a bang (!), it indicates that unlike its non-bang equivalent, permanently modifies its receiver**. **Almost always**, ruby core library will have a non-bang counterpart (method name which does NOT end with !) of every bang method (method name which does end with !) that does not modify the receiver. This convention is typically true for ruby core library but may or may not hold true for other ruby libraries.

Hightlited part of citation talks about that method with exclamation mark modifies its receiver. What is good because i could choose between imperative habit and modify receiver, but i can also create new data and code in functional habit.

Eg: i can create new array with **map** method, but always i can modify existed object with **map!**. What is incredible and easy to understand.
Or i want to get unique values from array by **uniq** assign into new variable. Still it is able to modify origin array with **uniq!**

Second highlighted part is about confused part. It tells to programmer be careful. Not all methods follows this great design.
In Ruby are methods which are "inconsistent" in naming.

Eg. Many built-in Array methods like
* clear
* concat
* delete
* delete_at
* delete_if
* fill
* insert
* keep_if
* pop
* push
* replace
* shift
* unshift
are dangerous because modify its receiver. What is confusing for many programmers and it brings unexceptional behaviour without study documentation deeper.

I think Ruby is popular for people because it communicate with programmer like in human language.
Nowadays are getting functional programming languages high popularity and trend increase more and more.

It could be great to remove that one word ("Almost") and have Ruby as language more clear, unambiguous and brings more functional principles into language what we like and love.



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

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