Issue #17316 has been updated by Dan0042 (Daniel DeLorme). The single-character syntax itself isn't a problem if limited to instance variables. `foo ?=` is already valid and shouldn't change, but `@foo ?=` isn't currently valid, so it could serve as "assign if ivar undefined." The problem is consistency. All operator-equals decompose uniformly (`a += b` -> `a = a + b`) but `?=` and its variations (like `@||=`) would be very different. What should happen with cases like: ```ruby foo ?= expr foo[key] ?= expr foo.bar ?= expr ``` If that's a syntax error, it's inconsistent with other operators like `+=` or `||=`. If it means "assign if not nil", it's inconsistent with `@foo ?= expr` as "assign if undefined". And if `@foo ?= expr` is changed to mean "assign if not nil" then we're back to the nil coalescing operator which is a different topic (#13820) An operator for "assign if undefined" is appealing, but the implications don't work out cleanly. ---------------------------------------- Feature #17316: On memoization https://bugs.ruby-lang.org/issues/17316#change-114347 * Author: sawa (Tsuyoshi Sawada) * Status: Open ---------------------------------------- I have seen so many attempts to memoize a value in the form: ```ruby @foo ||= some_heavy_calculation(...) ``` improperly, i.e., even when the value can potentially be falsy. This practice is wide spread, and since in most cases memoization is about efficiency and it would not be critical if it does not work correctly, people do not seem to care so much about correcting the wrong usage. In such case, the correct form would be: ```ruby unless instance_variable_defined?(:@foo) @foo = some_heavy_calculation(...) end ``` but this looks too long, and perhaps that is keeping people away from using it. What about allowing `Kernel#instance_variable_set` to take a block instead of the second argument, in which case the assignment should be done only when the instance variable is not defined? ```ruby instance_variable_set(:@foo){some_heavy_calculation(...)} ``` Or, if that does not look right or seems to depart from the original usage of `instance_variable_set`, then what about having a new method? ```ruby memoize(:foo){some_heavy_calculation(...)} ``` -- https://bugs.ruby-lang.org/