[#99115] [Ruby master Bug#17023] How to prevent String memory to be relocated in ruby-ffi — larskanis@...
Issue #17023 has been reported by larskanis (Lars Kanis).
22 messages
2020/07/10
[#99375] [Ruby master Feature#17055] Allow suppressing uninitialized instance variable and method redefined verbose mode warnings — merch-redmine@...
Issue #17055 has been reported by jeremyevans0 (Jeremy Evans).
29 messages
2020/07/28
[#101207] [Ruby master Feature#17055] Allow suppressing uninitialized instance variable and method redefined verbose mode warnings
— merch-redmine@...
2020/12/02
Issue #17055 has been updated by jeremyevans0 (Jeremy Evans).
[#101231] Re: [Ruby master Feature#17055] Allow suppressing uninitialized instance variable and method redefined verbose mode warnings
— Austin Ziegler <halostatue@...>
2020/12/03
What does this mean?
[ruby-core:99274] [Ruby master Feature#17016] Enumerable#scan_left
From:
msiegel@...
Date:
2020-07-22 18:12:50 UTC
List:
ruby-core #99274
Issue #17016 has been updated by RubyBugs (A Nonymous). parker (Parker Finch) wrote in #note-18: > I agree the name is not ideal. It is easy to get it confused with the idea of a string scanner. As you mentioned, `scan` is the name used by Haskell, but it is also used by [Scala](https://www.scala-lang.org/api/current/scala/Array.html), [Rust](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.scan), and [C++](https://en.cppreference.com/w/cpp/algorithm/inclusive_scan). So it is a widely-used term, even if it's not the best one, which makes me think that it might be good to use it. > > Alternatively, what do you think about the name `accumulate`, which [Wolfram uses](https://reference.wolfram.com/language/ref/Accumulate.html)? I think it gets the idea across better than `scan`. > > Are there other names you think should be considered? In keeping with the Ruby-ish collection methods that end with "-ect", how about * **reflect** -- the idea is to contrast with `inject`, this "reflects" all intermediate states * **project** -- the idea is that the original `Enumerable` is "projected" in a mathematical sense into the plane defined by the stateful function that is passed in (just my 2 cents...) ---------------------------------------- Feature #17016: Enumerable#scan_left https://bugs.ruby-lang.org/issues/17016#change-86662 * Author: parker (Parker Finch) * Status: Open * Priority: Normal ---------------------------------------- ## Proposal Add a `#scan_left` method to `Enumerable`. (The name "scan_left" is based on Scala's scanLeft and Haskell's scanl. It seems like "scan_left" would be a ruby-ish name for this concept, but I'm curious if there are other thoughts on naming here!) ## Background `#scan_left` is similar to `#inject`, but it accumulates the partial results that are computed. As a comparison: ``` [1, 2, 3].inject(0, &:+) => 6 [1, 2, 3].scan_left(0, &:+) => [0, 1, 3, 6] ``` Notably, the `scan_left` operation can be done lazily since it doesn't require processing the entire collection before computing a value. I recently described `#scan_left`, and its relationship to `#inject`, more thoroughly in [this blog post](https://medium.com/building-panorama-education/scan-left-a-lazy-incremental-alternative-to-inject-f6e946f74c00). ## Reasoning We heavily rely on the scan operation. We use an [event-sourcing](https://martinfowler.com/eaaDev/EventSourcing.html) pattern, which means that we are scanning over individual "events" and building up the corresponding state. We rely on the history of states and need to do this lazily (we stream events because they cannot fit in memory). Thus the scan operation is much more applicable than the inject operation. We suspect that there are many applications that could leverage the scan operation. [This question](https://stackoverflow.com/questions/1475808/cumulative-array-sum-in-ruby) would be more easily answered by `#scan_left`. It is a natural fit for any application that needs to store the incrementally-computed values of an `#inject`, and a requirement for an application that needs to use `#inject` while maintaining laziness. ## Implementation There is a Ruby implementation of this functionality [here](https://github.com/panorama-ed/scan_left/) and an implementation in C [here](https://github.com/ruby/ruby/pull/3078). ## Counterarguments Introducing a new public method is committing to maintenance going forward and expands the size of the Ruby codebase -- it should not be done lightly. I think that providing the functionality here is worth the tradeoff, but I understand any hesitation to add yet more to Ruby! ---Files-------------------------------- scan_left_example.rb (2.93 KB) -- https://bugs.ruby-lang.org/ Unsubscribe: <mailto:[email protected]?subject=unsubscribe> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>