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

Joao S. O. Bueno jsbueno at python.org.br
Mon Apr 9 08:17:47 EDT 2018


I have an idea for an inovative, unanbiguous, straightforward and
backwards compatible syntax for that,
that evena llows one to pass metadata along the operation so that the
results can be tweaked acording
to each case's needs.

What about:

new_data = dict_feed({
        "direct": "some data",
        "nested": {
            "lst_data": [1, 2, 3],
            "int_data": 1
        }
    },
data
)

we could even call this approach a name such as "function call".


In other words, why to bloat the language with hard to learn, error prone,
grit-looking syntax, when a simple plain function call is perfectly
good, all you need to do over
your suggestion is to type the function name and a pair of parentheses?




On 7 April 2018 at 14:26, thautwarm <yaoxiansamma at gmail.com> 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 } let IsMatchByName record1 (name:
> string) = match record1 with | { MyRecord.Name = nameFound; MyRecord.ID = _;
> } when nameFound = name -> true | _ -> false let recordX = { Name =
> "Parker"; ID = 10 } let isMatched1 = IsMatchByName recordX "Parker" let
> isMatched2 = 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/
>


More information about the Python-ideas mailing list