Right. Sorry. Yes, my second proposal involves the serializer *visiting* all elements in the data object *recursively* and calling `#to_hash` on them. This is how Rail's `#to_json` works when you serialize anything to the JSON format and I think it's a good solution, because even though it does make the core `#to_hash` implementation  more involved, it keeps adapter implementation simpler and less error prone: as long as `serializer_from_block_or_class` returns a serializer instance, it will work.

Keep in mind that, if needed, you can still call `#to_hash` directly on sub-serializers, because it will return a real hash and hashes respondo to `#to_hash` as well. In fact it makes it nicer because *anything* that responds to `#to_hash` will work. I guess I'm saying we should use duck-typing for the user's benefit.

I think my example above should work. It goes deep into the adapter's data and calling `#to_hash` recursively on any member that responds to that at any level, either a real hash or a sub-adapter.


## Option 3

Yet another option I just thought of is that the data object is our own internal class that calls `#to_hash` on things on assignation, ie when you do this

```ruby
data[:_embedded][name] = blah
```

... It would call `#to_hash` on `blah` internally, if supported. Something like:

```ruby
class Data < Hash
  # Make sure getting an unknown key lazily creates a nested Data object
  def [](key)
     if !has_key?(key)
       self[key] = Data.new
     end
     super
  end

  # Call #to_hash on values on assignation
  def []=(key, value)
    value = value.respond_to?(:to_hash) ? value.to_hash : value
    super[key] = value
  end
end
```

I tend to prefer the recursive #to_hash however.