Issue #6672 has been reported by prijutme4ty (Ilya Vorontsov).

----------------------------------------
Feature #6672: Calling #() without dot before braces
https://bugs.ruby-lang.org/issues/6672

Author: prijutme4ty (Ilya Vorontsov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


It looks odd to call Proc/Method `pr` using `pr.(*args)` or `pr[*args]` syntax. Why not to use pr(*args) syntax? In such a case methods(procs) would become nearer to first-class object and calls are more standardized such that there's much less difference between method call and call of #call method

So I suggest syntax `x.(*args,&block)` alias to `x(*args,&block)`
It will make it possible to transparently redefine any method in a scope like this:
class String
  def my_meth(direction)
    index = method :rindex  if direction == 'RtoL'
#   ... lots of code that uses #index method
  end

  def my_second_meth
    upcase = method :downcase  # we decided to try what if we change all upcases to downcases in this method and added such a line
# lots of code using upcase() method
    upcase()  # it's sad that it's impossible not to use brackets at all, but this'd be ambiguous
  end
end

Also I wrote about syntax like :meth.(*args) which creates a proxy-object having to_proc method - so that it's possible to write [1,2,3].map &:to_s.(2)  --  now no dot in such syntax

Also it'd be possible to implement some object with syntax like `obj(args1)(args2)` - obj has method #call that returns object that also has method #call and they are both called.
It can be in such a way: method(:index)('z')

One problem is that it can behave differently from current behavior in case that method have the same name as a local-variable. Now it works in such a way:
p='var'; 
print p #=> 'var'  ## works as local variable
p('hi') #=> 'hi'   ## works as method call

I don't know if it's a spec, I suppose that one mustn't use both variable and method at the same place. So even it's a spec it can be revised in future versions of ruby so that new behaviour would be like that:
p='var'; 
print p #=> 'var'  ## works as local variable
p('hi') #=> undefined method `call` for 'var':String



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