docs: function(prop) {
                      return function(instancesRawData, oldList) {
                          // Increment reqs counter so new instances will be added to the store.
                          // (This is cleaned up at the end of the method.)
                          can.Model._reqs++;
  
                          // If there is no data, we can't really do anything with it.
                          if (!instancesRawData) {
                              return;
                          }
  
                          // If the "raw" data is already a List, it's not raw.
                          if (instancesRawData instanceof this.List) {
                              return instancesRawData;
                          }
  
                          var self = this,
                              // `tmp` will hold the models before we push them onto `modelList`.
                              tmp = [],
                              // `ML` (see way below) is just `can.Model.List`.
                              ListClass = self.List || ML,
                              modelList = oldList instanceof can.List ? oldList : new ListClass(),
  
                              // Check if we were handed an Array or a model list.
                              rawDataIsArray = can.isArray(instancesRawData),
                              rawDataIsList = instancesRawData instanceof ML,
  
                              // Get the "plain" objects from the models from the list/array.
                              raw = rawDataIsArray ? instancesRawData : (
                                  rawDataIsList ? instancesRawData.serialize() : can.getObject(prop || "data", instancesRawData));
  
                          if (typeof raw === 'undefined') {
                              throw new Error('Could not get any raw data while converting using .models');
                          }
  
  
  
                          // If there was anything left in the list we were given, get rid of it.
                          if (modelList.length) {
                              modelList.splice(0);
                          }
  
                          // If we pushed these directly onto the list, it would cause a change event for each model.
                          // So, we push them onto `tmp` first and then push everything at once, causing one atomic change event that contains all the models at once.
                          can.each(raw, function(rawPart) {
                              tmp.push(self.model(rawPart));
                          });
                          modelList.push.apply(modelList, tmp);
  
                          // If there was other stuff on `instancesRawData`, let's transfer that onto `modelList` too.
                          if (!rawDataIsArray) {
                              can.each(instancesRawData, function(val, prop) {
                                  if (prop !== 'data') {
                                      modelList.attr(prop, val);
                                  }
                              });
                          }
                          // Clean up the store on the next turn of the event loop. (`this` is a model constructor.)
                          setTimeout(can.proxy(this._clean, this), 1);
                          return modelList;
                      };
                  }