Ability to create lists within lists, and extract lists within lists. Possibly some sort of advanced list node? Currently list tools only work on one list at a time. Lists within lists should be able to handle recursive lists to unlimited depth (within reason):

List A

List A

List A

X,Y,Z

List B

X,Y,Z

List B

List A

X,Y,Z

List B

X,Y,Z

Component: 

Notes from Team Vuo

Vuo Pro: 

No — available with both Vuo and Vuo Pro licenses

Complexity: 

●●○○ — A few weeks of work

Potential: 

●○○ — Appeals to current community

Comments

We planned out what all needs

jstrecker's picture
Submitted by
Feature status:
Chosen to be implemented
»
Open for community voting

We planned out what all needs to be done for this feature request, and realized we aren't going to be able to fit it into Vuo 1.3. Sorry :( I'm opening it back up for voting.

Lists-within-lists really would be a good thing to have in Vuo. The difficulty is that we'll need to rework a lot (more than we'd realized at first) of how lists are handled in Vuo. We had to choose between spending a lot of time on this feature or doing more of the top-voted features, and we chose the latter. Now that this feature is opened back up for voting, I hope you'll consider voting for it.

Now that this isn't in 1.3

alexmitchellmus's picture
Submitted by

Now that this isn't in 1.3 let's vote it up for 1.4! Guys we really need this for the future of Vuo. This is a serious feature - maybe not "exciting" or "cool" but it's extremely important. This will be needed for dealing correctly with multidimensional data (such as loaded from XML etc).

So remember VOTE! :-)

Yes, lists of lists!

Pianomatic's picture
Submitted by

Yes, lists of lists!

Out of curiosity, @Steve or @Jaymie, will the (eventual) implementation let us toss around lists via cables like any other type of data, or will there be some important differences?

I'd love to see the ability to treat a list like any other piece of data, doing away with the distinction between, for example, the Share Value and Share List nodes.

I'm wondering if you can't

useful design's picture
Submitted by

I'm wondering if you can't sort of do this already… maybe I'm wrong but if a list is a bunch of elements you could assume structure to the list were no actually is evident in the list.

say the list had 120 elements. you you define each element in the top level list as having 120 elements. that would make each element have 10 of it's own elements. (Stay with me here…)

The first, say, three items of each top level element could be (a, b ,c) followed by elements 4-10 null if not required (d, e, f, g, h, i, j). Now (a,b,c) could describe the indexes for a 3 dimensional Array, while (d, e, f, g, h, i ,j) could be the data elements.

I think the only change that would need to be made to Vuo and list handling to do this would be to allow different datatypes in lists. I don't know if that is allowed, not allowed or not disallowed but also not possible with existing Vuo nodes. I imagine one code write a node to put various datatypes into the elements if a new class of datatype was created to handle it. Almost all current nodes would not be able to receive such a deep list — only a couple would get modified to accept such complex data.

We would need a new Make Deep Listnode to accept multiple single element lists of various things incoming and building the master list from them and metadata about the nature of the construction from other value ports. It's how I imagined I would create my 'triangle structures' referred to on other Q&As i posted with 3x 3D points for each vertexes along with a colour value for each vertex. Then write a node to fiddle with some of the positioning using transforms etc either before initial master list is made or by modifying it (so either before Build a List or using Process a List and clumping 6 or more elements as blocks of data when I process it, each block describing a vertex and its colour) Then parse in a final node that converts the data to scene objects for rendering.

Lists already have a datatype other than 'list' associated with them obviously since we can have a list of integers as well as a list of 4D points and the Editor knows the difference. This in a sense is List metadata. Maybe we just need a bit more List metadata to describe more complex set ups.

Team Vuo could create two new datatypes, one of deep list or matrix (but it's a multi-typed matrix not the typical kind where all elements are the same type) and another datatype say multi-list for the deep list elements of, say, 10 items where the first 3 or 4 are positive integers that represent the array indexes (a, b, c) allowing say a 3 deep lists of lists of lists, and the following items in this object could also be predetermined so Vuo always expects the same basic datatype at each element, so d is real; e is text; f is 2D point; g is 3D point (which colours can be converted into); h is 4D Point (which CMYK colours can be in); i is image; j is layer elements… and so on. Or maybe just allow them to be anything and the user must set up the code to process them carefully.

Normal list handling nodes wouldn't know how to handle these Deep Lists but we could write our own nodes to peak and poke at them and perhaps Vuo could provide basic Make a Deep List and Get Elements from Deep List and Choose element from Deep List and Sort Elements by Index Orders from Deep List or Extract Data from Deep List nodes both of which would output a conventional list from a subset of the full data contained in the element. Plus a Change an Element in Deep List using Indexesfor poking at a bit of data in a single Multi-list element in the Deep List.

@Philip you mentioned that @Jaymie demoed a way of constructing a list using the Share List node somewhere else (forget where). Wondering if either of you have a link handy, if not no probs I expect I'll figure out how at some point.

I'd love to see the ability

jstrecker's picture
Submitted by

I'd love to see the ability to treat a list like any other piece of data, doing away with the distinction between, for example, the Share Value and Share List nodes.

Philip, yes, that's exactly what we had in mind :)

I'm wondering if you can't sort of do this already… maybe I'm wrong but if a list is a bunch of elements you could assume structure to the list were no actually is evident in the list.

Alastair, yes, one could build subcompositions or C nodes that input or output lists that have a certain structure, implementing a complex data type such as list-of-list on top of the simpler existing list data type. This could be a workaround until true lists-of-lists are implemented.

Ideally it would be better to be able to treat lists, lists-of-lists, etc. like any other data type, as Philip said.

Feature status

When we (Team Vuo) plan each release, we try to implement as many of the community's top-voted feature requests as we have time for. Vote your favorite features to the top! (How do Vuo feature requests work?)

  • Submitted to vuo.org
  • Reviewed by Team Vuo
  • Open for community voting
  • Chosen to be implemented
  • Released

Votes

28 votes so far!

Who voted?

Kewl's picture
useful design's picture
alexmitchellmus's picture
sinemod's picture