[ruby-core:110122] [Ruby master Feature#19027] .= syntax

[ruby-core:110122] [Ruby master Feature#19027] .= syntax

[jeromedalbert (Jerome Dalbert)]

Issue #19027 has been reported by jeromedalbert (Jerome Dalbert).

----------------------------------------
Feature #19027: .= syntax
https://bugs.ruby-lang.org/issues/19027

* Author: jeromedalbert (Jerome Dalbert)
* Status: Open
* Priority: Normal
----------------------------------------
I wish I could do this in Ruby:

```
records .= where.not(id: excluded_ids) if some_condition
```

instead of:

```
records = records.where.not(id: excluded_ids) if some_condition
```

We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

I rarely need this since most of the time self replacement methods like `gsub!` are available. Over my many years of Ruby programming I wished I could use a `.=` syntax maybe a handful of times, so this would be a rarely useful feature, but I find it to be quite elegant in the rare cases it could be needed.

Maybe this is just me being weird but I thought I would share.



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

[ruby-core:110123] [Ruby master Feature#19027] .= syntax

[hmdne (hmdne -)]

Issue #19027 has been updated by hmdne (hmdne -).


I like it, though one while reading that code could have a problem with attempting to find a `where` variable.

Perhaps a more clearer way to write this would be the following:

```
records.=where.not(id: excluded_ids) if some_condition
```

We also have a `&.` operator, perhaps we should see `.=` in a similar fashion.

----------------------------------------
Feature #19027: .= syntax
https://bugs.ruby-lang.org/issues/19027#change-99379

* Author: jeromedalbert (Jerome Dalbert)
* Status: Open
* Priority: Normal
----------------------------------------
I wish I could do this in Ruby:

```
records .= where.not(id: excluded_ids) if some_condition
```

instead of:

```
records = records.where.not(id: excluded_ids) if some_condition
```

We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

I rarely need this since most of the time self replacement methods like `gsub!` are available. Over my many years of Ruby programming I wished I could use a `.=` syntax maybe a handful of times, so this would be a rarely useful feature, but I find it to be quite elegant in the rare cases it could be needed.

Maybe this is just me being weird but I thought I would share.



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

[ruby-core:110125] [Ruby master Feature#19027] .= syntax

[mame (Yusuke Endoh)]

Issue #19027 has been updated by mame (Yusuke Endoh).

Status changed from Open to Rejected

If I remember correctly, this has been proposed several times. I found one ticket #6841, so I'll close this as a duplicate.

----------------------------------------
Feature #19027: .= syntax
https://bugs.ruby-lang.org/issues/19027#change-99383

* Author: jeromedalbert (Jerome Dalbert)
* Status: Rejected
* Priority: Normal
----------------------------------------
I wish I could do this in Ruby:

```
records .= where.not(id: excluded_ids) if some_condition
```

instead of:

```
records = records.where.not(id: excluded_ids) if some_condition
```

We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

I rarely need this since most of the time self replacement methods like `gsub!` are available. Over my many years of Ruby programming I wished I could use a `.=` syntax maybe a handful of times, so this would be a rarely useful feature, but I find it to be quite elegant in the rare cases it could be needed.

Maybe this is just me being weird but I thought I would share.



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

[ruby-core:110126] [Ruby master Feature#19027] .= syntax

[austin (Austin Ziegler)]

Issue #19027 has been updated by austin (Austin Ziegler).


jeromedalbert (Jerome Dalbert) wrote:
> I wish I could do this in Ruby:
> 
> ```
> records .= where.not(id: excluded_ids) if some_condition
> ```
> 
> instead of:
> 
> ```
> records = records.where.not(id: excluded_ids) if some_condition
> ```
 
I find that both unreadable and undecipherable, personally. This is one case where something like a pipeline operator might be better (https://bugs.ruby-lang.org/issues/15799).

```ruby
records =
  RecordSource
  |> where(…) # original condition
  |> maybe_exclude(some_condition, excluded_ids)

…

def maybe_exclude(records, condition, excluded_ids)
  condition ? records.where.not(id: excluded_ids) : records
end
```

It’s not *shorter*, but it allows for a better reading of the query build in the first place. It might be possible to do something like that using `Kernel#then`:

```ruby
records =
  RecordSource
    .where(…) # original condition
    .then { maybe_exclude(_1, some_condition, excluded_ids) }

…

def maybe_exclude(records, condition, excluded_ids)
  condition ? records.where.not(id: excluded_ids) : records
end
```

> We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

This would be different than the others, because `+=` &c. result in method calls on the receiver. If we wanted something clearer, maybe `records = &..when.not…` where `&..` would be a signal to "retrieve the previous variable symbol to use here".

----------------------------------------
Feature #19027: .= syntax
https://bugs.ruby-lang.org/issues/19027#change-99384

* Author: jeromedalbert (Jerome Dalbert)
* Status: Rejected
* Priority: Normal
----------------------------------------
I wish I could do this in Ruby:

```
records .= where.not(id: excluded_ids) if some_condition
```

instead of:

```
records = records.where.not(id: excluded_ids) if some_condition
```

We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

I rarely need this since most of the time self replacement methods like `gsub!` are available. Over my many years of Ruby programming I wished I could use a `.=` syntax maybe a handful of times, so this would be a rarely useful feature, but I find it to be quite elegant in the rare cases it could be needed.

Maybe this is just me being weird but I thought I would share.



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

[ruby-core:110127] [Ruby master Feature#19027] .= syntax

[Dan0042 (Daniel DeLorme)]

Issue #19027 has been updated by Dan0042 (Daniel DeLorme).


I don't think that works. `var += expr` is a shortcut for `var = var.+(expr)`. But `var .= method` translates to `var = var.method`; the right-hand side is not an expression, so it's a very different kind of construct.

But I'm a fan of the "fluent interface" style, so I wouldn't mind `records = .where.not(id: excluded_ids)`
:-)

(I would also love fluent-style
`foo && .bar`
`foo and .bar`
`foo{ .bar }` but #16120 has been rejected once so I don't think there's much hope.)

----------------------------------------
Feature #19027: .= syntax
https://bugs.ruby-lang.org/issues/19027#change-99385

* Author: jeromedalbert (Jerome Dalbert)
* Status: Rejected
* Priority: Normal
----------------------------------------
I wish I could do this in Ruby:

```
records .= where.not(id: excluded_ids) if some_condition
```

instead of:

```
records = records.where.not(id: excluded_ids) if some_condition
```

We already have `+=`, `-=`, `||=`, etc, so why not have a `.=` syntax?

I rarely need this since most of the time self replacement methods like `gsub!` are available. Over my many years of Ruby programming I wished I could use a `.=` syntax maybe a handful of times, so this would be a rarely useful feature, but I find it to be quite elegant in the rare cases it could be needed.

Maybe this is just me being weird but I thought I would share.



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