[Python-ideas] Is there any idea about dictionary destructing?

[Eric V. Smith]

There was a long thread last year on a subject, titled "Dictionary 
destructing and unpacking.":
https://mail.python.org/pipermail/python-ideas/2017-June/045963.html

You might want to read through it and see what ideas and problems were 
raised then.

In that discussion, there's also a link to an older pattern matching thread:
https://mail.python.org/pipermail/python-ideas/2015-April/032907.html

Eric

On 4/7/2018 1:26 PM, thautwarm wrote:
> We know that Python support the destructing of iterable objects.
> 
> m_iter= (_for _in range(10))
> a,*b, c= m_iter
> 
> That's pretty cool! It's really convenient when there're many corner 
> cases to handle with iterable collections.
> However destructing in Python could be more convenient if we support 
> dictionary destructing.
> 
> In my opinion, dictionary destructing is not difficult to implement and 
> makes the syntax more expressive. A typical example is data access on 
> nested data structures(just like JSON), destructing a dictionary makes 
> the logic quite clear:
> 
> data= {
>      "direct": "some data",
>      "nested": {
>          "lst_data": [1,2,3],
>          "int_data": 1
> }
> }
> {
>     "direct": direct,
>      "nested": {
>          "lst_data": [a, b, c],
>      }
> }= data
> 
> 
> Dictionary destructing might not be very well-known but it really helps. 
> The operations on nested key-value collections are very frequent, and 
> the codes for business logic are not readable enough until now. Moreover 
> Python is now popular in data processing which must be enhanced by the 
> entire support of data destructing.
> 
> Here are some implementations of other languages:
> Elixir, which is also a popular dynamic language nowadays.
> 
> |iex> %{} = %{:a => 1, 2 => :b} %{2 => :b, :a => 1} iex> %{:a => a} = 
> %{:a => 1, 2 => :b} %{2 => :b, :a => 1} iex> a 1 iex> %{:c => c} = %{:a 
> => 1, 2 => :b} ** (MatchError) no match of right hand side value: %{2 => 
> :b, :a => 1}|
> 
> And in F#, there is something similar to dictionary 
> destructing(actually, this destructs `struct` instead)
> type MyRecord = { Name: string; ID: int } letIsMatchByName record1 
> (name: string) = matchrecord1 with| { MyRecord.Name = nameFound; 
> MyRecord.ID = _; } whennameFound = name -> true| _ -> falseletrecordX = 
> { Name = "Parker"; ID = 10} letisMatched1 = IsMatchByName recordX 
> "Parker"letisMatched2 = IsMatchByName recordX "Hartono"
> 
> All of them partially destructs(or matches) a dictionary.
> 
> thautwarm
> 
> 
> 
> _______________________________________________
> Python-ideas mailing list
> Python-ideas at python.org
> https://mail.python.org/mailman/listinfo/python-ideas
> Code of Conduct: http://python.org/psf/codeofconduct/
>