Imagine | 🖼️ PNG/JPEG optimization app for macOS, Windows and Linux | Compression library

According to the language reference, chapter 3 "Data model" (see here):

An object’s type determines the operations that the object supports (e.g., “does it have a length?”) and also defines the possible values for objects of that type. The type() function returns an object’s type (which is an object itself). Like its identity, an object’s type is also unchangeable.[1]

which, to my mind states that the type must never change, and changing it would be illegal as it would break the language specification. The footnote however states that

[1] It is possible in some cases to change an object’s type, under certain controlled conditions. It generally isn’t a good idea though, since it can lead to some very strange behaviour if it is handled incorrectly.

I don't know of any method to change the type of an object from within python itself, so the "possible" may indeed refer to the CPython function.

As far as I can see a PyObject is defined internally as a

The long execution time comes from the fact that each child of a Parent registers a listener with the disabled and treeVisible properties of that Parent. The way JavaFX is currently implemented, these listeners are stored in an array (i.e. a list structure). Adding the listeners is relatively low cost because the new listener is simply inserted at the end of the array, with an occasional resize of the array. However, when you remove a child from its Parent and the listeners are removed, the array needs to be linearly searched so that the correct listener is found and removed. This happens for each removed child individually.

So, when you clear the children list of the Group you are triggering 1,000,000 linear searches for both properties, resulting in a total of 2,000,000 linear searches. And to make things worse, the listener to be removed is either--depending on the order the children are removed--always at the end of the array, in which case there's 2,000,000 worst case linear searches, or always at the start of the array, in which case there's 2,000,000 best case linear searches, but where each individual removal results in all remaining elements having to be shifted over by one.

There are at least two solutions/workarounds:

1. Don't display 1,000,000 nodes. If you can, try to only display nodes for the data that can actually be seen by the user. For example, the virtualized controls such as ListView and TableView only display about 1-20 cells at any given time.

2. Don't clear the children of the Group. Instead, just replace the old Group with a new Group. If needed, you can prepare the new Group in a background thread.

   Doing it that way, it took 3.5 seconds on my computer to create another Group with 1,000,000 children and then replace the old Group with the new Group. However, there was still a bit of a lag spike due to all the new nodes that needed to be rendered at once.

   If you don't need to populate the new Group then you don't even need a thread. In that case, the swap took about 0.27 seconds on my computer.

The most basic form of the kind language contains only * (or Type in more modern Haskell; I suspect we'll eventually move away from *) and ->.

But there are more things you can build with that language than you can express by just "counting the number of *s". It's not just the number of * or -> that matter, but how they are nested. For example * -> * -> * is the kind of things that take two type arguments to produce a type, but (* -> *) -> * is the kind of things that take a single argumemt to produce a type where that argument itself must be a thing that takes a type argument to produce a type. data ThreeStars a b = Cons a b makes a type constructor with kind * -> * -> *, while data AlsoThreeStars f = AlsoCons (f Integer) makes a type constructor with kind (* -> *) -> *.

There are several language extensions that add more features to the kind language.

PolyKinds adds kind variables that work exactly the same way type variables work. Now we can have kinds like forall k. (* -> k) -> k.

ConstraintKinds makes constraints (the stuff to the left of the => in type signatures, like Eq a) become ordinary type-level entities in a new kind: Constraint. Rather than the stuff left of the => being special purpose syntax fairly disconnected from the rest of the language, now what is acceptable there is anything with kind Constraint. Classes like Eq become type constructors with kind * -> Constraint; you apply it to a type like Eq Bool to produce a Constraint. The advantage is now we can use all of the language features for manipulating type-level entities to manipulate constraints (including PolyKinds!).

DataKinds adds the ability to create new user-defined kinds containing new type-level things, in exactly the same way that in vanilla Haskell we can create new user-defined types containing new term-level things. (Exactly the same way; the way DataKinds actually works is that it lets you use a data declaration as normal and then you can use the resulting type constructor at either the type or the kind level)

There are also kinds used for unboxed/unlifted types, which must not be ever mixed with "normal" Haskell types because they have a different memory layout; they can't contain thunks to implement lazy evaluation, so the runtime has to know never to try to "enter" them as a code pointer, or look for additional header bits, etc. They need to be kept separate at the kind level so that ordinary type variables of kind * can't be instantiated with these unlifted/unboxed types (which would allow you to pass these types that need special handling to generic code that doesn't know to provide the special handling). I'm vaguely aware of this stuff but have never actually had to use it, so I won't add any more so I don't get anything wrong. (Anyone who knows what they're talking about enough to write a brief summary paragraph here, please feel free to edit the answer)

There are probably some others I'm forgetting. But certainly the kind language is richer than the OP is imagining just with the basic Haskell features, and there is much more to it once you turn on a few (quite widely used) extensions.

You could use django's receiver annotation.

For example, if you want to detect any call of the save method, you could do:

Laziness to the rescue. We can recursively define a list of all the sub-automata, such that their transitions index into that same list:

There is no "or" operator for generics, and for a simple reason.

The idea of stating the type at the beginning is to allow you to use methods from that type in your implementation of the class.

When you use the "and" operator (extends A & B), you know that whatever object is passed to you, you can access any of the A class's methods as well as any of the B class's method.

But what would happen if it was an "or"? Then you are passed an object that can either be a ComboBoxItem allowing you to use ComboBoxItem's methods, or it is just a string, which means you can't use any such methods. At compile time, you don't know which object you are passed, so there is no point in giving the type.

The "Or" is not helpful. If you are not using any method from the object, you may as well not use extends at all.

The real question here is what you are trying to do which can apply to strings as well as combo box items but not to anything else. It smells like a design issue.

Vocabulary

This is getting exactly at the distinction between inductive and co-inductive types, which we so like to ignore in Haskell. But you can't do that on the type level, because the compiler needs to make proofs in finite time.

So, what we need is to actually express the type-level stream in co-inductive fashion:

I think this algorithm does what you want, but it's not very efficient. It may provide others with a starting point for faster solutions.