Hi all, I've just joined you, I hope I'll not make you loose your time with questions already covered. Sorry, if my suggest represents lot of work (certainly too much) and about my lack of knowledge about internal implementation, but I hope opening a discussion can help. I would suggest to introduce a new statement to provide a way to extend language syntax. Abstract: While reading this article about None history<http://python-history.blogspot.fr/2013/11/story-of-none-true-false.html>I realised I was not alone to wonder about some aspect of the language. Some of these are: - constant and immutability - null object and "None is a singleton" - readability of code *Constant:* It's a convention, no matter with that. My question is more if there is no memory overuse to have fixed values that behave as variable. *Null Object:* NoneType is not overridable. Having null objects instance of NoneType wouldn't make sense ? Can't assign keywords so "None is a singleton". Wouldn't it be more simple to have "keyword" type and be able to assign a keyword to a variable ? With an object hierarchy like: keyword <- ReservedKeyword I find it can make clearer why some keywords are reserved without changing actual behaviour. *Readability of code:* I have shouldDsl <http://www.should-dsl.info/> use case in mind. The introduction illustrate my thought: "*The goal of Should-DSL is to write should expectations in Python as clear and readable as possible, using an “almost” natural language (limited by some Python language’s constraints).*" I find ShouldDsl perturbing, as the aim is laudable but the implementation stays a hack of the language. I see the influence of functional paradigm in this syntax and agreed with the fact it becomes a "must have". I love Python syntax and find, it has very few limits, but maybe it can be improved by reducing some constraints. One concerns in extending syntax is that the language can evolve on users usage. I see it like an open laboratory where developpers experiments new keywords like "should" implemented in their favorite language and when this keyword is largely accepted by the community it can finally integrate the core. *A solution*: I was first thinking of a statement like "Instance" to declare an immutable object with a single instance (like None), but I then consider how it would be great to be able to extend the syntax. I thought the keyword "Keyword", which exists in clojure for example<http://clojure.org/data_structures#Data%20Structures-Keywords>, can do the job. A first implementation can be: Keyword <name>(<keyword, literal or object>): field = <something> # fixed value: self.field = "something" will raise an error def behaviour(self, *args, **kwargs): # do something def __get__(self, left, right, block_content): # what to do when accessing keyword Inline implementation: Keyword <name>(<keyword, literal or object>) *Examples of use:* *Constant*: Keyword Pi(3.14159) *Null Object* and immutable objects: Class Person(object): def __init__(self, name): self.name = name JohnDoe = Person(name="anonymous") Keyword Anonymous(None, JohnDoe) Anonymous.name = "JohnDoe" # raise an error assert isinstance(Anonymous, type(None)) # is true As Anonymous is immutable , it is also thread safe. The mecanism which consist of freezing an object can be applied in other situation. An interesting approach can be to define keywords identity throught a hash of their value, like value object. *Should keyword*: Keyword ShouldEqual(keyword): def __get__(self, left, right, block): if left != right: raise AssertError() ### weird examples: *Multiline Lambdas*: Keyword MultilineLambda(keyword): def __get__(self, left, right, block_content): def multiline_lambda(*args, **kwargs): self.assert_args_valid(right, args, kwargs) # compare "right" (tuple) with args and raise exception in case not valid return self.run(block_content, args, kwargs) # "run" is a shortcut because I don't know which type is the most appropriate for block content return multiline_lambda divide = MultilineLambda a, b: if b == 0: raise MyDivideByZeroError() return a/b *Reimplementing else*: Keyword otherwise(keyword): def __get__(self, left, right, block): if left: return # left is the result of "if" block self.run(block) if something: # do something otherwise: # other Whereas this example is weird, it seems to me that we can better figure out what language do. Thanks all to have kept python open and give us opportunities to freely discuss about its future implementation. Have a nice day, Grégory