On Mon, Apr 30, 2018 at 08:52:13PM -0500, Tim Peters wrote: > > Would/should it be possible to inject a name into a local scope? You can't > > inject into a function scope, and names in a function scope can be > > determined statically (they are allocated slots), so could the same kind of > > thing be done for names in a local scope? > > Sorry, I'm unclear on what "inject a name into a local scope" means. > Do you mean at runtime?
I don't know what MRAB means by "inject", but I know what *I* mean, and I have a real use-case for it. There is a long-running micro-optimization, often championed by Raymond, for avoiding slow global lookups (and even slower builtin lookups, since they require a global lookup to fail first) by turning them in local lookups at function-definition time. E.g. some methods from the random.Random class: def randrange(self, start, stop=None, step=1, _int=int): ... def _randbelow(self, n, int=int, maxsize=1<<BPF, type=type, Method=_MethodType, BuiltinMethod=_BuiltinMethodType): ... (copied from 3.5, I don't know what the most recent version looks like) That's a nice way to make the binding: _int = int occur once only, instead of putting it inside the function body which then needs to be executed on ever call. Effectively it's a static variable for the method, one which persists from one call to the next without requiring re-initialisation. But it's ugly :-( The function signature is full of *implementation details* instead of the parameters needed for the method's interface. Look at _randbelow which takes one actual parameter, n, plus FIVE fake parameters, int, maxsize, type, Method and BuiltinMethod, none of which should ever be passed arguments. So when I talk about injecting values into a function, that is the sort of thing I'm referring to: at function definition time, push or inject a reference to a known value (say, the builtin int) into something which behaves as a static variable. It would be nice if we could do that without polluting the function signature. I'll admit that the name "inject" came to me when I was thinking of some hypothetical decorator: @inject(int=int, maxsize=1<<BPF, type=type, ...) def _randbelow(self, n): ... that somehow pushed, or *injected*, those bindings into the function, turning them into locals, but in an alternative universe where Guido loved making new keywords, I'd use a static initialisation block and stick it inside the def: def _randbelow(self, n): static: # this gets executed once only, at function definition time int=int maxsize=1<<BPF type=type # body of _randbelow ... -- Steve _______________________________________________ Python-ideas mailing list Python-ideas@python.org https://mail.python.org/mailman/listinfo/python-ideas Code of Conduct: http://python.org/psf/codeofconduct/