[#35599] Proc#== behaviour on 1.8.7 and 1.9.2 — Adam Prescott <adam@...>
I've encountered a problem when using Proc#== (with both lambdas and
[#35613] [Ruby 1.9 - Feature #4539][Assigned] Array#zip_with — Yui NARUSE <redmine@...>
> http://redmine.ruby-lang.org/issues/4539
Hi,
[#35618] Redmine issues — Benoit Daloze <eregontp@...>
Hello,
[#35621] [Ruby 1.9 - Bug #4555][Open] [PATCH] ext/socket/init.c: rsock_connect retries on interrupt — Eric Wong <normalperson@...>
[#35629] [Ruby 1.9 - Bug #4473] Calling return within begin still executes else — Mayank Kohaley <redmine@...>
[#35631] [Ruby 1.9 - Bug #4558][Open] TestSocket#test_closed_read fails after r31230 — Tomoyuki Chikanaga <redmine@...>
> ----------------------------------------
KOSAKI Motohiro <[email protected]> wrote:
Tomoyuki Chikanaga <[email protected]> wrote:
> Issue #4558 has been updated by Eric Wong.
KOSAKI Motohiro <[email protected]> wrote:
[#35632] [Ruby 1.9 - Bug #4559][Open] Proc#== does not match the documented behaviour — Adam Prescott <redmine@...>
(2012/11/28 16:10), matz (Yukihiro Matsumoto) wrote:
I believe this will be a spec change, albeit a small one. Can we
[#35636] [Ruby 1.9 - Feature #4560][Open] [PATCH] lib/net/protocol.rb: avoid exceptions in rbuf_fill — Eric Wong <redmine@...>
[#35637] [Ruby 1.9 - Bug #4561][Open] 1.9.2 requires parentheses around argument of method call in an array, where 1.8.7 did not — Dave Schweisguth <redmine@...>
[#35644] [Ruby 1.8 - Bug #4563][Open] Dir#tell broken — Daniel Berger <redmine@...>
[#35648] mvm branch status? — Eric Wong <normalperson@...>
Hello, I noticed the "mvm" branch in SVN hasn't been updated in over a year.
Hi Eric.
Has there been any thought on solving the C extension problem in MVM? In the present state, I've stopped working on it in Rubinius because there is no workable solution if there are C extensions in the mix.
Evan Phoenix <[email protected]> wrote:
On Thu, Apr 7, 2011 at 6:18 PM, Eric Wong <[email protected]> wrote:
[#35666] caching of the ancestor chain — Xavier Noria <fxn@...>
Why does Ruby cache the ancestors chain? I mean, not why the implementation i=
Ah, in case it is not clear, where I find the metaphor broken is in that you=
Hi,
On Fri, Apr 8, 2011 at 7:56 PM, Yukihiro Matsumoto <[email protected]> wro=
[#35678] [Ruby 1.9 - Bug #4564][Open] mingw-w64, truncate, ftruncate and ftello -- properly evalute it's existence — Luis Lavena <redmine@...>
[#35699] [Ruby 1.9 - Feature #4568][Open] [PATCH] file.c (rb_group_member): kill 256K of stack usage — redmine@...
[#35707] [Ruby 1.9 - Feature #4569][Open] Replace IPAddr with IPAddress — redmine@...
[#35713] [Ruby 1.9 - Bug #4571][Open] YAML.load given an ISO8601 timestamp creates an incorrect value for usec — redmine@...
[#35734] [Ruby 1.9 - Feature #4574][Open] Numeric#within — redmine@...
[#35753] [Ruby 1.9 - Bug #4576][Open] Range#step miss the last value, if end-exclusive and has float number — redmine@...
Can somebody please reopen this issue? Since the test suite fix is
2011/9/16 Marc-Andre Lafortune <[email protected]>:
On 16 September 2011 15:49, Tanaka Akira <[email protected]> wrote:
Hi,
2011/9/16 Kenta Murata <[email protected]>:
2011/9/17 Marc-Andre Lafortune <[email protected]>:
2011/9/17 Tanaka Akira <[email protected]>:
(2011/09/17 9:07), Tanaka Akira wrote:
I have not been watching ruby-core, but let me give a comment for this issu=
2011/9/17 Masahiro TANAKA <[email protected]>:
2011/9/20 Tanaka Akira <[email protected]>:
I haven't explained the reason of the error estimation in
On 21 September 2011 14:25, masa <[email protected]> wrote:
[#35754] [Ruby 1.9 - Bug #4577][Open] (int...float).max should not raise an error — redmine@...
[#35759] [Ruby 1.8 - Bug #4578][Open] Fixnum.freeze not frozen? — redmine@...
[#35765] [Ruby 1.9 - Bug #4579][Open] SecureRandom + OpenSSL may repeat with fork — redmine@...
[#35777] hashes are not consistent across ruby processes? — Roger Pack <rogerdpack2@...>
Hello all.
[#35813] [Ruby 1.9 - Bug #4320] Bus Error in digest/sha2 on sparc — redmine@...
[#35814] [Ruby 1.9 - Bug #4320] Bus Error in digest/sha2 on sparc — redmine@...
[#35825] [Ruby 1.8 - Bug #4587][Open] RMATCH_REGS definition is wrong — redmine@...
[#35828] [Ruby 1.9 - Feature #4589][Open] add Queue#each() method and include Enumerable — redmine@...
[#35830] [Ruby 1.9 - Feature #3436] Spawn the timer thread lazily — redmine@...
[#35850] [Ruby 1.9 - Feature #4189] FileUtils#ln_r — Sakuro OZAWA <redmine@...>
[#35866] [Ruby 1.9 - Bug #4603][Open] lib/csv.rb: when the :encoding parameter is not provided, the encoding of CSV data is treated as ASCII-8BIT — yu nobuoka <nobuoka@...>
On Sun, Apr 24, 2011 at 1:33 AM, yu nobuoka <[email protected]>wrote:
2011/4/25 James Gray <[email protected]>:
On Sun, Apr 24, 2011 at 11:29 PM, NARUSE, Yui <[email protected]> wrote:
[#35879] [Ruby 1.9 - Bug #4610][Open] Proc#curry behavior is inconsistent with lambdas containing default argument values — Joshua Ballanco <jballanc@...>
[#35883] [Ruby 1.9 - Bug #4611][Open] [BUG] Segementation fault reported — Deryl Doucette <me@...>
[#35895] [Ruby 1.9 - Feature #4614][Open] [RFC/PATCH] thread_pthread.c: lower RUBY_STACK_MIN_LIMIT to 64K — Eric Wong <normalperson@...>
[#35923] [Ruby 1.9 - Feature #4621][Open] NilClass#to_hash — Tsuyoshi Sawada <sawadatsuyoshi@...>
[#35933] [Ruby 1.9 - Bug #4623][Open] Consistent crash related to action_mailer — Alex Neth <alex@...>
[#35943] [Ruby 1.9 - Feature #3905] rb_clear_cache_by_class() called often during GC for non-blocking I/O — Motohiro KOSAKI <kosaki.motohiro@...>
[ruby-core:35905] [Ruby 1.9 - Feature #4601] Re-ordering method parameters.
Issue #4601 has been updated by Nicos Gollan.
Yusuke Endoh wrote:
> But I don't like your approach. It looks like an abuse of Proc#curry ;-)
It was just meant as an idea. You might call it positional currying, partial application, or whatever ;-)
Joshua Ballanco wrote:
> You can already do something similar with Method#to_proc and Proc#curry:
Your example shows the problem quite nicely, and that's what I am doing at the moment. It does not provide the functionality though.
> I've filed a different issue to ask about that behavior (#4610).
That looks like it'd be hard to use with splatting, but I guess for my requirements it would work something like:
def foo(a, b = "bar", c="baz"); "#{a} #{b} #{c}"; end
l = ->(m, a, b, c) {puts m.call(a, b, c)}
c = l.curry
c.(method(:foo)).('dog').().('cat')
and deal with the parameter-less calls through a mixture of the incoming parameters hash and Method#parameters.
When calling it "partial application", I think something like
keep_me = method(:foo).apply(:a => 'dog', :c => 'cat')
#=> unary proc/lambda/method
# ...
# 5 minutes later
keep_me.call('bird')
#=> "dog bird cat"
would still be useful in some places where you don't want complete evaluation, since you'd otherwise have to manually keep track of missing parameters until you can fill in the gaps.
----------------------------------------
Feature #4601: Re-ordering method parameters.
http://redmine.ruby-lang.org/issues/4601
Author: Nicos Gollan
Status: Open
Priority: Normal
Assignee:
Category:
Target version:
In my attempt to make an old gem (merb-action-args) work with MRI 1.9.2, Rubinius, and other implementations that depend on Method#parameters to retrieve a description of parameters, I hit a roadblock (the core reason is that it is not possible to retrieve parameter defaults). To quote the gem's README:
== Original Problem: Out of order defaults
class Foo < Merb::Controller
def bar(one, two = "dos", three = "tres")
"#{one} #{two} #{three}"
end
end
The interesting thing here is that hitting "/foo/bar?one=uno&three=three" will call foo("uno", "dos", "three"). In other words, the defaults can be in any order, and merb-action-args will figure out where to fill in the holes.
== Parameter Omission
This reordering feature means we need some way to omit parameters when calling a method, thus maintaining defaults. Originally, that was done by direct access to the AST, which is not really an option anymore with 1.9 and other VMs like Rubinius. One possible, but ugly syntax for straight omission would be:
class Pet
def quack(a, b='quack', c='woof')
"#{a} #{b} #{c}"
end
end
Pet.new.quack('meow', , 'whinny') #=> "meow quack whinny"
Now, IMO, this looks quite ugly, and would be hard to make work with the ubiquitous *args pattern.
== Currying Extension
Another way to enable that behaviour would be parameter reordering, i.e., some way to map a Proc with n parameters to a method with >=n parameters. For the problem I am facing, that would mean I could curry the called method in a way so that all missing parameters are shifted to the end, and calling the resulting method with an appropriate list would preserve defaults. For example:
Assume the parameters passed to the quack action of the Pet controller are values for a and c. Then define a curried method:
quack_proxy =
pet_instance.method(:quack).curry(
2, # number of parameters in the resulting method
[0, 2, 1] # parameter order of the called method
)
# or alternatively use parameter names, omit defaults, ...:
quack_proxy =
pet_instance.method(:quack).curry(2, [:a, :c])
The resulting Proc quack_proxy would have the signature:
# quack_proxy(a, c='woof', b='quack')
quack_proxy.call(*['this', 'works'])
# => "this quack works"
== Proposed Currying Syntax/Semantics
(Proc) (({Method#curry(num_args, order = nil)}))
Returns a proxy with num_args arguments to the receiver.
When order is nil, the parameters of the receiver are mapped to the first num_args parameters of the proxy in order.
When order is an Array of integers or symbols with order.size >= num_args, it describes the order in which the parameters of the proxy are mapped to the receiver. Required parameters not named or indexed are mapped in order of their appearance.
In cases where not all required parameters of the receiver are covered, an ArgumentError is raised.
Examples:
def foo(req_a, req_b, opt_a=1, obt_b=2, opt_c=3); end
m = Kernel.method(:foo)
m.curry(2)
# maps to foo(req_a, req_b) with all optional parameters at defaults
m.curry(3, [0, 1, :opt_b])
# maps to foo(req_a, req_b, opt_b=2) with optionals a and c at defaults
m.curry(5, [0, 1, :opt_b])
# maps to foo(req_a, req_b, opt_b=2, opt_a=1, opt_c=3)
m.curry(1, [:req_b])
# raises ArgumentError (not all required parameters covered)
ret = m.curry(2, [:req_b])['hello']
# maps to foo(req_a, 'hello') with all optionals at defaults
# NOTE: this results in an unary method.
In the last example, the call to #curry creates a 2-ary Proc, which maps the first parameter to the req_b parameter of #foo, implicitly maps the second parameter to req_a, and hides all optional parameters. Then, by using #[] like Proc#[], the first parameter to the proxy is assigned. Since the second parameter is required, this returns an unary Proc.
--
http://redmine.ruby-lang.org