I am against this idea, as I°«ve had more problems with `undefined` in
JavaScript than I have had with most other values, including null. I
believe that I°«ve needed to implement a °»default sigil°… object (like the
Undefined object in DRY) maybe twice in the last 17 years and I°«ve seen it
in the wild in a couple of other places.

This, to me, adds more _magic_ behaviour to Ruby that is somewhat
unexplainable, whereas using a `missing` sigil object (e.g., Undefined)
requires explicit handling and is fairly clear.

This _could_ be fixed in some ways if it were possible to override the `||`
or `or` operators so that you could define an instance that returns the
other side:

sigil = Object.new
class << sigil
  def @||(other)
    other
  end
end

-a

On Mon, Nov 4, 2019 at 4:35 PM <bughitgithub / gmail.com> wrote:

> Issue #11660 has been updated by bughit (bug hit).
>
>
> >  Ruby having a single nil, instead of JavaScript's null and undefined,
> is a net benefit, in my opinion.
>
> undefined signals the absence of a value and makes possible composable
> default value design, where missing arguments can be forwarded and still
> trigger default value computation, which is a clear win for javascript.
>
> > The popularity of an idea is not always a proxy to its merit, but if
> nobody else thinks the benefits of a proposal exceed the costs, maybe it
> isn't worth implementing.
>
> Ok got it. Popularity does not always equal merit, but often it does and
> this must be one of those times, because of course it has no merit and it's
> unpopular. Ergo ipso facto, it has no merit.
>
> ----------------------------------------
> Feature #11660: a falsy value (similar to js undefined) that facilitates
> forwarding of default arguments
> https://bugs.ruby-lang.org/issues/11660#change-82467
>
> * Author: bughit (bug hit)
> * Status: Open
> * Priority: Normal
> * Assignee:
> * Target version:
> ----------------------------------------
> I'll call it "missing" here.  Consider the following scenario:
>
> ```ruby
> def foo(default1 = some_expression)
> end
>
> def bar(default1 = some_expression)
>   foo default1
> end
>
> def foobar(default1 = some_expression)
>   bar default1
> end
> ```
>
> if you had "missing":
>
> ```ruby
> def foo(default1 = some_expression)
> end
>
> def bar(default1 = missing)
>   foo default1
> end
>
> def foobar(default1 = missing)
>   bar default1
> end
> ```
> missing passed as arg would be ignored (as if it wasn't passed at all)
> and you wouldn't have to repeat the default value expression in every
> method
>
> I believe that's how undefined works in js6 with respect to default args
>
>
>
>
> --
> 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>
>


-- 
Austin Ziegler  halostatue / gmail.com  austin / halostatue.ca
http://www.halostatue.ca/  http://twitter.com/halostatue
(supressed text/html)
Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>