Can you please be more specific? Is it something like #6214?

'cause for that, I'm proposing a dict Colormap/Norm of the form:

cmap, norm = mcolors.DictColor({'snow':'gray', 'rain':'blue, 'broken detector':red})

since scatter and imshow both take cmap and norm, that could probably handle the separations...and then possibly a helper legend of sorts that does legend_from_cmapnorm or something? (or hooking it directly into legend...but I expect more pushback there...)

Which part is unclear?
Yes, I think it is a duplicate of #6214.

I implemented both the "legend from colormap" helper and the for-loop approach. I think the for-loop is much cleaner. And I think the right way to go about this is to use cyclers (though I'm not entirely sure yet).

The question is whether you want symbols and colors to be able to use the same variable or different variables. In my application, I'm currently using the same variable for both. But having different variables to go 4d or beyond also makes sense.

Though I guess if you support discrete variables for any of the mutable attributes you can just register one cycler for each, and you can do both things.

Sorry, didn't realize you'd already implemented it. (That's what was unclear...I thought you were making a feature request)

There was a discussion with @tacaswell about making a bunch of the attributes cyclers to support stuff like when an array gets passed in..hmm, I'm wondering how you can keep them independent if they're all cyclers cause wouldn't the cyclers still be acting on the same aggregations? (like row 0 of the passed in array all gets the first color, symbol, size in the cycler, etc...

I'm partial to a categorical cmap 'cause it would work for both imshow and scatter and it has the advantage of not requiring the user to group their data-pretty sure a cycler would require some preaggregation.

ETA: this has me thinking about a function that probably doesn't belong in matplotlib but lets you define the group colors, markers, sizes, etc...and then plots each subset accordingly...but this would also probably get visually noisy really fast

Well either solution if implemented for my purposes is like 10 lines. Implementing them feature-complete in matplotlib is probably more ;)
So it is a feature-request mixed with volunteering to contribute ;)

Yeah the aggregation for the cycler is a bit of a bummer.
But you could do
python scatter(x, y, c=categorical1, s=categorical2, marker=categorical3)
and different variables would get different cyclers.

But you could do python scatter(x, y, c=categorical1, s=categorical2, marker=categorical3)

Hmm, categorical1, 2, and 3 would either be dicts, tuples, or nested lists (or I guess enumerated types)? Something with a (key:value) structure..which granted, is the same thing that the colormap that I'm calling dict but should likely be a CategoricalColor that accepts anything that supports (key,value) enumeration (sorry, stream of conscious fleshing out 'cause better mpl categorical support is my gsoc project and working through what I wanna propose next)

But any which way, I dunno if that could be supported straight or if it's the sort of thing that should be pitched to seaborne (if they don't already support it...) since I think each (c,s,m) triplet acts on a subset of the data...and I dunno if all that subsetting breaks the matplotlib rule of sorts of trying to avoid manipulating the data (yes hist manipulates the data, but it's sort of in matplotlib for matlab/historical reasons and there's an issue/PR about factoring out the plotting there)

I was thinking about categoricalX to be numpy arrays or lists of integers. That currently works with color, and I don't see why that shouldn't work with others. That is problematic for s and marker, though, because there integers already have semantics.
That is one of the question of "should this go in the same function".
It would also be possible to add new kwargs like c_cycle or something with a better name, to use numpy arrays of integers. Actually, they wouldn't need to be integers, they could be anything.

What would the dict look like?

Another approach would be to do something like marker=apply_cycler(categorical3, my_cycler) which uses the cycler to assign markers to the entries of categorical. That throws away the values of categorical3, though, so that is no good for generating the labels / legends.

That currently works with color,

I'm pretty sure that's just 'cause then color gets visualized using a cmap. s can already take an array for the same reason-it just gets directly mapped.

Markers though don't have a continuous mapping, so it would require a) ensuring the input was discrete, b) coming up with a logical scheme for marker mapping (and what if np.unique(markers)<number(available(markers))

I'm thinking the data structure in these cases is something like (catagory name, category style element)

{'early':yellow', 'middle':orange, 'late':red}
{'early':'+', 'middle':'.', 'late':'o'}

Granted, I also feel like I'm conflating two use cases here:
grouped: user is passing in an N (groups) by M (observations matrix for which cyclers of N elements make sense - this is the use case for cyclers for all the kwargs (and is common for line plots especially)

ungrouped: user is passing in cols C1 and C2 of a table wherein cols C3, C4, and C5 are discrete variables that the data can be grouped on, or they're passing in a matrix of classes - this is the use case for [(key, value)] based kwargs (but on the flip side, this also fails in that there'd have to be a way to grab the values in C3, C4, and C5 too...)

The solution is a bit non-obvious. Happy to provide feedback on my use-cases, but I have no time to dive deeper into a solution for now.

You can use seaborn for this.
http://stanford.edu/~mwaskom/software/seaborn/generated/seaborn.lmplot.html#seaborn.lmplot

I might really need to move to seaborn (like many others did).

It's written on top of mpl/takes an mpl axis, so you can always mix and match as needed.

This is kind of a dupe of #6214

I agree. Feel free to close in favor of #6214.