1. Not if it is exactly as described in PEP. 2. No. 3. - 4. Couple of points here. One check and one orthogonal idea, which would make this PEP very attractive to me. I would definitely like use this functionality if both of below points were satisfied/achievable. If any of those weren't satisfied I might just default to current syntax as I like to have a default pattern, which I know is flexible enough to cover most if not all the cases that I encounter. Currently, I manage this particular area (which your PEP is concerned with) with `None` and `unittest.Sentinel` defaults and deal with them in function's body. A.------------------------------------------------ Currently, if I write: ``` def foo(bar=A()): pass class A: pass ``` I get an error. That is why having `bar=None` is advantageous. This works ok: ``` def foo(bar=None): if bar is None: bar = A() class A: pass ``` If PEP is aiming to replace the latter example, then it would be great if it kept all of its advantages. I.e. not having to change the definition order in the module, which could be preferred as it is for other reasons. My best guess is that it works the same as the latter example, (given the expression can contain other arguments, which are not there yet) but just wanted to double check. B.------------------------------------------------ And also to come back to my previous notice that there is no way to enforce the default in case of function chain with cascading arguments. You said it is a known limitation. Is there no easy & sensible approach to not have it? E.g.: a) Any object which has certain dunder attribute, which evaluates to True? b) NotGiven sentinel value which does exactly that. c) A special constant, which, if present, at lower level makes things behave the same way as the argument wasn’t provided at all. Such constant could be very useful outside the scope of this PEP as well. Could be a great place to introduce such constant? And to me it seems it could be a well justified one, given it actually is special and does not fall under umbrella of generic sentinel values. It would be great if it was to retain all the benefits of the latter example. Then (at least from my POV) this PEP would be an excellent addition, and I am most likely be using it now if it existed. Regards, DG