ruby-core

I am against this idea, as I=E2=80=99ve had more problems with `undefined` =
in
JavaScript than I have had with most other values, including null. I
believe that I=E2=80=99ve needed to implement a =E2=80=9Cdefault sigil=E2=
=80=9D object (like the
Undefined object in DRY) maybe twice in the last 17 years and I=E2=80=99ve =
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 =3D Object.new
class << sigil
  def @||(other)
    other
  end
end

-a

On Mon, Nov 4, 2019 at 4:35 PM <[email protected]> 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 =3D some_expression)
> end
>
> def bar(default1 =3D some_expression)
>   foo default1
> end
>
> def foobar(default1 =3D some_expression)
>   bar default1
> end
> ```
>
> if you had "missing":
>
> ```ruby
> def foo(default1 =3D some_expression)
> end
>
> def bar(default1 =3D missing)
>   foo default1
> end
>
> def foobar(default1 =3D 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:[email protected]?subject=3Dunsubscrib=
e>
> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>
>


--=20
Austin Ziegler =E2=80=A2 [email protected] =E2=80=A2 [email protected]=
a
http://www.halostatue.ca/ =E2=80=A2 http://twitter.com/halostatue

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