visibility issues with lists containing direct "copies" of objects

Try and keep lists consistent, either {A,B,C} or {(1,2),(3,4),(5,6)}

Do you have a good reason to mix them up?

Edit: sorry, ignore that

This advice must be written in help of list

De acuerdo

Creo recordar que hubo una época, hace un par de años, en que la visualización de puntos y conjuntos de puntos era doble y para evitar esto se hizo que los puntos y conjuntos de puntos dejaran de ser visibles simultáneamente, de forma que si un punto se ocultaba entonces el conjunto de puntos se ocultaba o algo parecido. Puede que esto sea un efecto secundario de aquellos intentos de hacer compatible la visualización de objetos y listas de esos objetos al mismo tiempo

@Michael I would like a bit of clarification about lists. I considered lists to be powerful tools, but your sentence "Try and keep lists consistent, either {A,B,C} or {(1,2),(3,4),(5,6)}" kinda makes me lose a lot of confidence in them.

Even though Geogebra seemingly allows lists of all kinds of objects, it has become clear that certain list operations are only guaranteed to work properly when the objects in the lists are "of the same type" (even the elements are in principle compatible), although it is becoming increasingly unclear what "of the same type" actually means.

Mostly, list operations seem to work fine when all elements are of the same type (in the sense of what a user might intuitively consider the same type), but I am starting to wonder how much of that is just happenstance (in that the current implemention happens to work the way we expect in most cases) but is far from guaranteed because the result actually depends strongly on some miniscule details that a user has amost no chance of knowing.

So I am gonna try to formulate some questions, hoping that the answers shed some light onto this.

1. When defining a list via "{<Element>,...,<Element>}", which ways of representing an <Element>, e.g.

   • literals (e.g. "(1,1)" as a point literal)
   • names of already defined objects (e.g. "A")
   • expressions containing object names, but not just an object name itself (e.g. "A*1")

   are considered to be "of different type" (in terms of what kind of list is created), even if - from a user perspective - they all have the same type, e.g. "point"?

   If there are such different "types", does mixing those "types" produce "bad" lists (and operations on such a list might produce wrong results)?

2. If yes, is "mixing" only a problem upon list creation or are the resulting lists from different non-mixing definitions still of inherently "different type" and incompatible for certain list operations?
3. If still yes, how can I find what kind of hidden subtype a list has or whether two lists are compatible?

   Or is there a standard way to make them (more) compatible? (Always assuming that the elements are compatible in principle, e.g. the lists contain only points.)

To give an example, consider the following

A = (1,1)
B = (2,2)
L_1 = {(1,1), (2,2)}
L_2 = {A, B}
L_3 = {A*1, B*1}
L_4 = {(1,1), B}
L_5 = {(1,1), B*1}
L_6 = {A, B*1}
L_7 = Sequence((k, k), k, 1, 2)

I'd say >99% of users would assume that

• at the moment after the definition, the all six lists L_1, ..., L6 are of the same type ("list of points") and have the same content
• as long as the values of A, B, C don't change - operating with any of the lists would produce the same outcome

But maybe that's not the case. Your earlier remark suggests that L_1 and L_2 are "good" (maybe still inherently different types of list, but operations on them would produce the same outcome), but that the "mixed" L_4 is "bad" (and operations on L_4 might produce wrong results).

And based on the different visibilty behaviour discussed in this thread, it also seems that L_2 and L_3 are inherently different, which suggests that the "mixed" L_6 might also be "bad".

Not 100% sure about L_1 vs. L_3, but they might also be inherently different and L_5 might be "bad".

And what about L_7, is L_7 the same as L_1 or is there another difference?

And are L_1 and L_2 be compatible to be joined for example, i.e., can I safely use "Join(L_1, L_2)" or "Join({L_1, L_2})" or does that produce a "bad" list?

More generally, are there list operations that a guaranteed to be safe, even if the list contains elements of different types? (and here I even consider really different types)

I am assuming that at least "Length(<List>)" is safe, and I am hoping that "Element(<List>, <Position>)" is safe (as long as I don't do inappropriate stuff with the result), so we can use lists as variable length storage even if GeoGebra might consider some elements to be of a different type.