Python and Ruby

[Chris Rebert]

On Mon, Feb 1, 2010 at 2:28 PM, Jonathan Gardner
<jgardner at jonathangardner.net> wrote:
> On Jan 31, 3:01 am, rantingrick <rantingr... at gmail.com> wrote:
>> On Jan 30, 10:43 am, Nobody <nob... at nowhere.com> wrote:
>> > That's also true for most functional languages, e.g. Haskell and ML, as
>> > well as e.g. Tcl and most shells. Why require "f(x)" or "(f x)" if "f x"
>> > will suffice?
>>
>> yuck! wrapping the arg list with parenthesis (python way) makes the
>> most sense. Its to easy to misread somthing like this
>>
>> onetwothree four five six
>>
>> onetwothree(four, five, six) #ahhh... plain english.
>
> In Lisp-ish languages, you have a list of stuff that represents a
> function call:
>
>  (a b c d)
>
> means: Call "a" with values (b, c, d)
>
> While this certainly doesn't agree with what you learned in Algebra,
> it is a reasonable syntax that exposes the code-data duality of
> programs. There is, however, one fatal flaw. Why is the first element
> so different than the rest? This is inconsistent with what people who
> are unfamiliar with the language would expect. Indeed, in teaching
> Lisp, learners have to be reminded about how the evaluator looks at
> lists and processes them.
>
> I would expect a clear, simple language to have exactly one way to
> call a function. This calling notation would clearly distinguish
> between the function and its parameters. There are quite a few
> options, and it turns out that "function(arg, arg, arg)" is a really
> good compromise.
>
> One of the bad things with languages like perl and Ruby that call
> without parentheses is that getting a function ref is not obvious. You
> need even more syntax to do so. In perl:
>
>  foo();       # Call 'foo' with no args.
>  $bar = foo;  # Call 'foo; with no args, assign to '$bar'
>  $bar = &foo; # Don't call 'foo', but assign a pointer to it to '$bar'
>              # By the way, this '&' is not the bitwise-and '&'!!!!
>  $bar->()     # Call whatever '$bar' is pointing at with no args
>
> Compare with python:
>
>  foo()       # Call 'foo' with no args.
>  bar = foo() # 'bar' is now pointing to whatever 'foo()' returned
>  bar = foo   # 'bar' is now pointing to the same thing 'foo' points to
>  bar()       # Call 'bar' with no args
>
> One is simple, consistent, and easy to explain. The other one requires
> the introduction of advanced syntax and an entirely new syntax to make
> function calls with references.

Ruby isn't nearly as bad as Perl in this regard; at least it doesn't
introduce extra syntax (though there are extra method calls):

foo    # Call 'foo' with no args.
bar = foo  # Call 'foo; with no args, assign to bar
bar = method(:foo)  # 'bar' is now referencing the 'foo' "function"
bar.call    # Call 'bar' (i.e. 'foo') with no args

Cheers,
Chris
--
http://blog.rebertia.com