Why specify fields by type instead of index in Elasticsearch?

If multiple types in an Elasticsearch index have fields with the same name, those fields must have the same mapping, which tries to create the "foobar" property (string and long).

For example, if you try to put the following index mapping:

{
  "mappings": {
    "type_one": {
      "properties": {
        "foobar": { 
          "type": "string"
        }
      }
    },
    "type_two": {
      "properties": {
        "foobar": { 
          "type": "long"
        }
      }
    }
  }
}

...will return the following error

{
  "error": {
    "root_cause": [
      {
        "type": "mapper_parsing_exception",
        "reason": "Failed to parse mapping [type_one]: mapper [foobar] cannot be changed from type [long] to [string]"
      }
    ],
    "type": "mapper_parsing_exception",
    "reason": "Failed to parse mapping [type_one]: mapper [foobar] cannot be changed from type [long] to [string]",
    "caused_by": {
      "type": "illegal_argument_exception",
      "reason": "mapper [foobar] cannot be changed from type [long] to [string]"
    }
  },
  "status": 400
}

Here's what's from the elasticsearch website:

Conflicts between fields of different types

Fields with the same name in two different types with the same name must have the same mapping because they are internally backed by the same fields. Attempting to update a map parameter for a field where more than one type exists will throw an exception unless you specify the update_all_types parameter, in which case it will update the parameter in all fields with the same name in the same index.

If fields with the same name must have the same mapping for all types in the index, then why specify a field mapping for each type? Why not specify the fields for the entire index and then decide which fields to assign to each type.

For example something like this:

{
   "fields":{
      "PropA":{
         "type":"string"
      },
      "PropB":{
         "type":"long"
      },
      "PropC":{
         "type":"boolean"
      }
   },
   "types":{
      "foo":[
         "PropA",
         "PropB"
      ],
      "foo":[
         "PropA",
         "PropC"
      ],
      "foo":[
         "PropA",
         "PropC",
         "PropC"
      ]
   }
}

Wouldn't such a mapping format be more concise and better represent what is actually allowed?

The reason I'm asking is because I'm creating an index template JSON file that contains about 80 different fields used in 15 types. Many fields are available for multiple types, if not all types. So whenever I need to update a field, I have to make sure it is updated for every type that uses the field.