Looks good! What do you think about including the types along with the labels?

Yeah, I'm not opposed. The two are equivalent in that we can use rowcons to look up the types. It'd probably be more convenient to have both though. In that case, what do you think about the names RowEntries/EntryList?

I was thinking RowToList originally. I'm hoping that we can build up a library of these sorts of classes: folds, maps, etc. once we have constraint kinds so that we can take a MPTC as an argument:

class RowMap f xs ys | f xs -> ys

instance auto1 :: RowMap f () ()
instance auto2 :: (f a b, RowMap f r1 r2) => RowMap f (l :: a | r1) (l :: b | r2)

Oh instead of two classes we can have the fundeps in both directions RowToList r l | r -> l, l -> r.

With the new bidirectional fundep, what would the instances look like if you wrote them out? Does the coverage condition hold in both directions?

What I'm getting at is that a fundep doesn't just depend on the relation you're defining, but also how you define it, right? Like, numeric addition as a 3-way relation has the property that if you know two, you know the third, but in practice we define it by recursion on one or the other argument, so the coverage condition doesn't actually hold for one of the fundeps, I think.

Ah yeah, because RowList doesn't have the ordering invariant it means multiple RowLists can compute the same rows. So the bidirectional fundep doesn't make sense. Thanks!
I'll switch back to two classes when I get some time.

Rebased on master. If I add a test now, it will either depend on my typelevel-prelude clone, or it will fail until we decide where to put the class.

Thanks, looks great!

A little test I did in the REPL, for reference:

> data LProxy (list :: RowList) = LProxy
> :p
… f :: forall proxy row list. RowToList row list => proxy row -> LProxy list
… f _ = LProxy

> :t f { x: 1, y : 2}
LProxy (Cons "x" Int (Cons "y" Int Nil))

> -- testing open rows
> :t \o -> o.x (f o)
forall t4 t5 t8.            
  RowToList                 
    ( x :: LProxy t5 -> t8  
    | t4                    
    )                       
    t5                      
   => { x :: LProxy t5 -> t8
      | t4                  
      }                     
      -> t8

👍 Looks really great!