From: shyouhei@... Date: 2020-04-30T02:50:35+00:00 Subject: [ruby-core:98089] [Ruby master Feature#13820] Add a nil coalescing operator Issue #13820 has been updated by shyouhei (Shyouhei Urabe). bsarrazin (Ben Sarrazin) wrote in #note-7: > Kotlin has this feature, Swift has this feature, many other languages have this feature. No. Kotlin does not have this feature (distinguish `false` and `null`). It is a really bad idea for you to refer Kotlin to have something like that. Kotlin is a statically typed language, and its `||` operator does not take nullable values. No confusion over `false` versus `null` must happen. That is why they need `?:` operator; they need something similar to `||` which also work for nullables. So if you want a ruby operator because `false` and `nil` are confusing, that's a totally different story than Kotlin's. PS. I'm not against the feature itself. I'm just telling that other languages have their own design that do not immediately apply here. ---------------------------------------- Feature #13820: Add a nil coalescing operator https://bugs.ruby-lang.org/issues/13820#change-85325 * Author: williamn (William Newbery) * Status: Open * Priority: Normal ---------------------------------------- It would be nice if Ruby had an operator that only considered `nil` as false, like the null coalescing operators or "Logical Defined-Or operator" (Perl) found in some other languages. Ive seen things like `//` and `//=`m `??` and `??=`, or `?:` used for this. This would work like `||` and `||=` for short circuiting etc. except that only `nil` is considered a false condition. While Ruby considers only "false" and "nil" as false, with everything else true ("", [], {}, etc.) I still find occasionally people trip up when using logical or, `||` and `||=` when the value may be false. ```ruby a = 0 || 55 # = 0 Ruby already considers 0, "", etc. as true (oter languages do differ a lot here) a = 0 ?? 55 # = 0 So no change here a = nil || 55 # = 55, nil is false so right side is evaulated. a = nil ?? 55 # = 55, again no change a = false || 55 # = 55, however false is false for logical or a = false ?? 55 # = false, but its still a non-nil value ``` For example when doing things like: ```ruby def lazy @lazy ||= compute_this end def fetch(id, **opts) host = opts[:host] || default_host https = opts[:https] || true port = opts[:port] || (https ? 443 : 80) ... ``` Normally the intention is to use a default value or compute an action if no value is provided, which if the value may be false then requires special handling, or sometimes is missed and results in a bug. -- 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>