code: function(type){
          if (type === undefined) {
              return undefined;
          }
          var getSchema = type[getSchemaSymbol];
          if(getSchema === undefined ) {
              type = type.constructor;
              getSchema = type && type[getSchemaSymbol];
          }
          return getSchema !== undefined ? getSchema.call(type) : undefined;
      }
docs: @function can-reflect.getSchema getSchema
  @parent can-reflect/shape
  @description Returns the schema for a type or value.
  
  @signature `getSchema(valueOrType)`
  
  Calls the `@can.getSchema` property on the `valueOrType` argument. If it's not available and
  `valueOrType` has a `constructor` property, calls the `constructor[@can.getSchema]`
  and returns the result.
  
  ```js
  import canReflect from "can-reflect";
  
  var Type = DefineMap.extend({
  name: "string",
  id: "number"
  });
  
  canReflect.getSchema( Type ) //-> {
  //   type: "map",
  //   keys: {
  //     name: MaybeString
  //     id: MaybeNumber
  //   }
  // }
  ```
  
  
  @param  {Object|Function} valueOrType A value, constructor function, or class to get the schema from.
  @return {Object} A schema. A schema for a [can-reflect.isMapLike] looks like:
  
  
  ```js
  {
  type: "map",
  identity: ["id"],
  keys: {
  id: Number,
  name: String,
  complete: Boolean,
  owner: User
  }
  }
  ```
  
  A schema for a list looks like:
  
  ```js
  {
  type: "list",
  values: String
  keys: {
  count: Number
  }
  }
  ```