PyWart: More surpises via "implict conversion to boolean" (and other steaming piles!)

[Travis Griggs]

On Feb 11, 2014, at 7:52 AM, Chris Angelico <rosuav at gmail.com> wrote:

> On Wed, Feb 12, 2014 at 2:36 AM, Travis Griggs <travisgriggs at gmail.com> wrote:
>> OTOH, I’m not sure I’ve heard the parameters-less functions are a code one? Is it just loose functions that you’re 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 (“passing a paragraph”).
>> 
> 
> '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):
> 
> some_file.close() # "Close some_file"
> some_list.shuffle() # "Shuffle some_list"
> some_file.readline() # "Some_file, read in a line"
> 
> There are times when, for convenience, the object is implicit.
> 
> print("some text", file=some_file) # Print that text
> print(file=some_file) # Print a blank line
> print("some text") # Print that text to sys.stdout
> print() # Print a blank line to sys.stdout
> 
> 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’m reading is that actually making a “no arg function” is difficult, if we widen the semantics. The “arguments” of a function may be bound to its implicit self parameter, or tied to module state.

> 
> 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’t 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’t 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’s just going to see something like

print vs print()

or 

aPoint.transpose vs aPoint.transpose()