Path: csiph.com!newsfeed.hal-mli.net!feeder3.hal-mli.net!newsfeed.hal-mli.net!feeder1.hal-mli.net!newsfeed.xs4all.nl!newsfeed1a.news.xs4all.nl!xs4all!newsgate.cistron.nl!newsgate.news.xs4all.nl!post.news.xs4all.nl!not-for-mail
Content-Type: text/plain; charset=windows-1252
Mime-Version: 1.0 (Mac OS X Mail 7.1 \(1827\))
Subject: Re: PyWart: More surpises via "implict conversion to boolean" (and other steaming piles!)
From: Travis Griggs <travisgriggs@gmail.com>
In-Reply-To: <CAPTjJmq7iqZwC1Vf74imv1ETg651D4xNTyzgB_tToyYqyCd71A@mail.gmail.com>
Date: Tue, 11 Feb 2014 08:19:24 -0800
Content-Transfer-Encoding: quoted-printable
References: <85c2698c-d681-4511-b111-bb1e549ece93@googlegroups.com> <52f9c392$0$11128$c3e8da3@news.astraweb.com> <4E8B29DC-F3A3-44A4-B912-9438CE56B3F2@gmail.com> <CAPTjJmq7iqZwC1Vf74imv1ETg651D4xNTyzgB_tToyYqyCd71A@mail.gmail.com>
To: "python-list@python.org" <python-list@python.org>
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.6681.1392135575.18130.python-list@python.org>
Lines: 70
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:65925


On Feb 11, 2014, at 7:52 AM, Chris Angelico <rosuav@gmail.com> wrote:

> On Wed, Feb 12, 2014 at 2:36 AM, Travis Griggs =
<travisgriggs@gmail.com> wrote:
>> OTOH, I=92m not sure I=92ve heard the parameters-less functions are a =
code one? Is it just loose functions that you=92re referring to? As =
opposed to methods (which are just bound functions)? I could maybe =
accept that. But methods with fewer arguments, and even none, are a =
desirable thing. There are code smells that are the opposite in fact, =
methods with long parameter lists are generally seen as code smell =
(=93passing a paragraph=94).
>>=20
>=20
> 'self' is, imo, a parameter. When you call a parameter-less method on
> an object, it's usually an imperative with a direct object (or
> sometimes a subject):
>=20
> some_file.close() # "Close some_file"
> some_list.shuffle() # "Shuffle some_list"
> some_file.readline() # "Some_file, read in a line"
>=20
> There are times when, for convenience, the object is implicit.
>=20
> print("some text", file=3Dsome_file) # Print that text
> print(file=3Dsome_file) # Print a blank line
> print("some text") # Print that text to sys.stdout
> print() # Print a blank line to sys.stdout
>=20
> So in that situation, the no-args call does make sense. Of course,
> this is a call to a function that does take args, but it's accepting
> all the defaults and providing no additional content. It's quite
> different to actually define a function that mandates exactly zero
> arguments, and isn't making use of some form of implicit state (eg a
> closure, or maybe a module-level function that manipulates
> module-level state - random.random() would be an example of the
> latter). Syntactically, Python can't tell the difference between
> "print()" and "foo()" where foo can never take args.

So at this point, what I=92m reading is that actually making a =93no arg =
function=94 is difficult, if we widen the semantics. The =93arguments=94 =
of a function may be bound to its implicit self parameter, or tied to =
module state.

>=20
> I'd say that a function taking no args is code smell, unless it's
> obviously taking its state from somewhere else (callbacks, for
> instance - maybe you pass a bound method, or maybe a closure, but in
> either case it has implicit state that's not described by function
> args); but _calling_ with no args isn't as smelly. It's certainly less
> common than using args, but there are plenty of times when a type is
> called without args, for instance[1].

Which leaves me wondering, how would I get my code to smell this way =
then? What IS an example of a no arg function that doesn=92t have an =
implicit object, that smells? It seems I can  escape the smell clause, =
as long as I find some data that I reason is attached to my function.

This all aside, I don=92t think these are what the OP had in mind. A =
code inspection algorithm is not going to be able to discern when an =
explicitly parameterless function has implicit parameters. It=92s just =
going to see something like

print vs print()

or=20

aPoint.transpose vs aPoint.transpose()

=20=