News for hackers. Stuff that matters.
Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @04:19PM (#41584969)
Who is out here mixing types in a list anyway?
Re:A high-performance, zero-overhead, extensible Python comp... by dathinab on Wednesday September 18, 2024 @06:46PM (#41586457)
parsing json is roughly of the type:

type Json = None | bool | float | str | dict[str, Json] | list[Json]

you might have similar situations for configs e.g. float | str for time in seconds or a human readable time string like "30s" etc.

given how fundamental such things are I'm not sure if there will be any larger projects (especially wrt. web servers and similar) which are compatible with this

also many commonly used features for libraries/classes etc. are not very likely to work (but idk. for sure, they just are very dynamic in nature)

so IMHO this seems to be more like a python-like language you can use for idk. some since computations and similar then a general purpose faster python

Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @06:55PM (#41586536)
Agreed, I was just joking. I understand heterogenous lists are possible with Python, but with the use of static type checking I feel like its pretty rare for me to have heterogenous lists unless its duck typing.
Re:A high-performance, zero-overhead, extensible Python comp... by JonChesterfield on Wednesday September 18, 2024 @11:18PM (#41588159)
If your language obstructs heterogeneous lists your programs will tend to lack them. Look for classes containing multiple hashtables from the same strings to different object types as a hint that they're missed.

Whether that's a feature is hard to say. Your language stopped you thinking in those terms, and stopped your colleagues from doing so. Did it force clarity of thought or awkward contortions in the implementation? Tends to depend on the domain.

Re:A high-performance, zero-overhead, extensible Python comp... by bobbylarrybobby on Thursday September 19, 2024 @03:10PM (#41595254)
Heterogeneity is easily achieved in statically typed languages via sum types.
Re:A high-performance, zero-overhead, extensible Python comp... by orf on Wednesday September 18, 2024 @04:28PM (#41585057)
It’s common to have a list of objects with different types, but which implement the same interface. Duck typing of this kind is core to Python.
Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @06:53PM (#41586521)
Good point.
Re:A high-performance, zero-overhead, extensible Python comp... by itishappy on Wednesday September 18, 2024 @04:45PM (#41585248)
The json module returns heterogenous dicts.

https://docs.python.org/3/library/json.html

Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @06:53PM (#41586526)
Yeah, just because it can do that doesn't mean that it is good design.
Re:A high-performance, zero-overhead, extensible Python comp... by gpderetta on Thursday September 19, 2024 @08:51AM (#41591334)
how would you represent an arbitrary JSON array in python then? A potentially heterogeneous list seems the obvious solution.
Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Thursday September 19, 2024 @02:42PM (#41594981)
Why would I want to do that? I'm rarely ingesting arbitrary JSON. Rather I'm designing my data structures in a sensible way and then maybe serializing them to JSON. Just because JSON can represent heterogenous lists doesn't mean it is a good idea to use heterogenous lists in my programs.
Re:A high-performance, zero-overhead, extensible Python comp... by gpderetta on Friday September 20, 2024 @04:37AM (#41599993)
The JSON spec does not require a schema. If you want to write a library that can support any valid JSON you have little options. That's useful if you are implementing something like jq just to give an example.
Re:A high-performance, zero-overhead, extensible Python comp... by gwking on Thursday September 19, 2024 @09:54AM (#41591854)
It is the design of JSON! Which is a reflection of the same dynamic typing choice made in the original design of Javascript.
Re:A high-performance, zero-overhead, extensible Python comp... by mrguyorama on Thursday September 19, 2024 @01:31PM (#41594220)
They, uh, still aren't wrong hah.

Tell me again why we somehow standardized on sending the equivalent of JSObject.toString() for everything? Especially when "standardized" isn't

Re:A high-performance, zero-overhead, extensible Python comp... by CaptainNegative on Wednesday September 18, 2024 @04:29PM (#41585071)
I often find myself mixing Nones into lists containing built-in types when the former would indicate some kind of error. I could wrap them all into a nullable-style type, but why shouldn't the interpreter implicitly handle that for me?
Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @06:53PM (#41586519)
Yeah, that seems fair.
Re:A high-performance, zero-overhead, extensible Python comp... by nicce on Wednesday September 18, 2024 @04:32PM (#41585110)
Everyone who chooses the Python in the first hand.
Re:A high-performance, zero-overhead, extensible Python comp... by bpshaver on Wednesday September 18, 2024 @06:52PM (#41586511)
Well, I'm one of those people, and I feel that I rarely do this. Except if I have a list of different objects that implement the same interface, as another commenter mentioned.
Re:A high-performance, zero-overhead, extensible Python comp... by RogerL on Wednesday September 18, 2024 @07:02PM (#41586577)
return [key, value]
Re:A high-performance, zero-overhead, extensible Python comp... by ghxst on Wednesday September 18, 2024 @09:39PM (#41587613)
Why would you do this over `return key, value` which produces a tuple? Just curious.
Re:A high-performance, zero-overhead, extensible Python comp... by dgan on Thursday September 19, 2024 @01:31AM (#41588829)
Not the parent, but i return heterogeneous lists of the same length to the excel to be used by xlwings. The first row being the headers, but every row below is obviously heterogeneous
Re:A high-performance, zero-overhead, extensible Python comp... by 0xDEADFED5 on Thursday September 19, 2024 @04:52AM (#41589897)
javascript refugee?
Re:A high-performance, zero-overhead, extensible Python comp... by slightwinder on Thursday September 19, 2024 @08:23AM (#41591069)
To quote the Zen of Python:

    Explicit is better than implicit.
    Readability counts.
Re:A high-performance, zero-overhead, extensible Python comp... by ErikBjare on Thursday September 19, 2024 @02:20PM (#41594736)
How does that apply in this case?
Re:A high-performance, zero-overhead, extensible Python comp... by slightwinder on Friday September 20, 2024 @07:40AM (#41600990)
"return key, value" is implicit. While "return [key, value]" is explicitly telling the full return-value. And it's (for me) more readable than "return (key, value)".
Re:A high-performance, zero-overhead, extensible Python comp... by Nab443 on Saturday September 21, 2024 @01:16AM (#41607670)
I don't see how "return (key, value)" is less readable than it's list counterpart. Now, why using a list that can grow, and so takes more space and maybe less efficient, for something that should not?
Re:A high-performance, zero-overhead, extensible Python comp... by slightwinder on Tuesday September 24, 2024 @08:38AM (#41635857)
"return (key, value)" can be read as a function-call. Especially as space after the function-name is allowed in python. And performance on that level is no serious topic in python anyway. But this is mainly just a personal preference.
Re:A high-performance, zero-overhead, extensible Python comp... by ghxst on Sunday September 22, 2024 @02:24PM (#41618891)
A list and tuple are not the same thing. There could be reasons to require a list explicitly but I couldn't really think of any obvious ones which is why I asked.
Re:A high-performance, zero-overhead, extensible Python comp... by Myrmornis on Thursday September 19, 2024 @08:05AM (#41590916)
You should use a tuple there: it's a collection of fixed size where each slot has an identity. (There's a common confusion in Python circles that the main point of tuples is immutability; that's not so).
Re:A high-performance, zero-overhead, extensible Python comp... by __mharrison__ on Wednesday September 18, 2024 @08:37PM (#41587210)
Someone who is using Python the wrong way.
Re:A high-performance, zero-overhead, extensible Python comp... by dekhn on Wednesday September 18, 2024 @09:25PM (#41587532)
I've been mixing types in Python lists for several decades now. Why wouldn't you? it's a list of PyObjects.
Re:A high-performance, zero-overhead, extensible Python comp... by gwking on Thursday September 19, 2024 @10:32AM (#41592324)
An example related to JSON content is HTML content. I have a Python library that represents all of the standard HTML tags as a family of classes. It is like a lightweight DOM on the server side, and has resulted in a web server that does not use string based templating at all. It lets me construct trees of HTML completely in Python and then render them out with everything correctly escaped. I can also parse HTML into trees and manipulate them as I please (for e.g. scraping tasks and document transforms). It is all strongly typed using mypy and I adhere to the strictest generic typing I can manage.

Each node has a list of children, and the element type is `str|HtmlNode`. I find this vastly easier to use than the LXML ETree api, where nodes have `text` and `tail` attributes to represent interleaved text.

Interestingly, the LXML docs promote their design as follows: > he two properties .text and .tail are enough to represent any text content in an XML document. This way, the ElementTree API does not require any special text nodes in addition to the Element class, that tend to get in the way fairly often (as you might know from classic DOM APIs). https://lxml.de/tutorial.html#elements-contain-text

It could be a simple matter of taste! But I suspect that the difference between what they are describing as "classic DOM" vs what I am doing is that they are referring to experience with C/C++/Java libraries circa 2009 that had much less convenient dynamic type introspection. The "get in the way fairly often" reminds me of how verbose it is to deal with heterogenous data in C/C++/ObjC. In ObjC for example, you could have an array mixing NSString with other NSObject subclasses, but you had to do work to type it correctly. If you wanted numbers in there you had to use NSNumber which is an annoying box type that you never otherwise use. And ObjC was considered very dynamic in its day!

I have long felt that the root of much evil was the overbearing distinction between primitive and object types in C++/Java/Objective-C.

All of this is a long way of saying, I think "how to deal with heterogenous lists of stuff" is a huge question in language design, library design, and the daily work of programming. Modern languages have by no means converged on a single way to represent varying types of elements. If you want to create trees of stuff, at some level that is "mixing types in a list" no matter how you might try to encode it. Just food for thought!