func DeepGet(data interface{}, path []string, fallback interface{}) interface{} {
	current := data

	for i := 0; i < len(path); i++ {
		part := path[i]

		switch current.(type) {
		//  arrays
		case []interface{}:
			currentAsArray := current.([]interface{})

			if stringutil.IsInteger(part) {
				if partIndex, err := strconv.Atoi(part); err == nil {
					if partIndex < len(currentAsArray) {
						if value := currentAsArray[partIndex]; value != nil {
							current = value
							continue
						}
					}
				}
			}

			return fallback

			//  maps
		case map[string]interface{}:
			currentAsMap := current.(map[string]interface{})

			if value, ok := currentAsMap[part]; !ok {
				return fallback
			} else {
				current = value
			}
		}
	}

	return current
}
func DeepSet(data interface{}, path []string, value interface{}) interface{} {
	if len(path) == 0 {
		return data
	}

	var first = path[0]
	var rest = make([]string, 0)

	if len(path) > 1 {
		rest = path[1:]
	}

	//  Leaf Nodes
	//    this is where the value we're setting actually gets set/appended
	if len(rest) == 0 {
		switch data.(type) {
		//  parent element is an ARRAY
		case []interface{}:
			return append(data.([]interface{}), value)

			//  parent element is a MAP
		case map[string]interface{}:
			dataMap := data.(map[string]interface{})
			dataMap[first] = value

			return dataMap
		}

	} else {
		//  Array Embedding
		//    this is where keys that are actually array indices get processed
		//  ================================
		//  is `first' numeric (an array index)
		if stringutil.IsInteger(rest[0]) {
			switch data.(type) {
			case map[string]interface{}:
				dataMap := data.(map[string]interface{})

				//  is the value at `first' in the map isn't present or isn't an array, create it
				//  -------->
				curVal, _ := dataMap[first]

				switch curVal.(type) {
				case []interface{}:
				default:
					dataMap[first] = make([]interface{}, 0)
					curVal, _ = dataMap[first]
				}
				//  <--------|

				//  recurse into our cool array and do awesome stuff with it
				dataMap[first] = DeepSet(curVal.([]interface{}), rest, value).([]interface{})
				return dataMap
			default:
				// log.Printf("WHAT %s/%s", first, rest)
			}

			//  Intermediate Map Processing
			//    this is where branch nodes get created and populated via recursion
			//    depending on the data type of the input `data', non-existent maps
			//    will be created and either set to `data[first]' (the map)
			//    or appended to `data[first]' (the array)
			//  ================================
		} else {
			switch data.(type) {
			//  handle arrays of maps
			case []interface{}:
				dataArray := data.([]interface{})

				if curIndex, err := strconv.Atoi(first); err == nil {
					if curIndex >= len(dataArray) {
						for add := len(dataArray); add <= curIndex; add++ {
							dataArray = append(dataArray, make(map[string]interface{}))
						}
					}

					if curIndex < len(dataArray) {
						dataArray[curIndex] = DeepSet(dataArray[curIndex], rest, value)
						return dataArray
					}
				}

				//  handle good old fashioned maps-of-maps
			case map[string]interface{}:
				dataMap := data.(map[string]interface{})

				//  is the value at `first' in the map isn't present or isn't a map, create it
				//  -------->
				curVal, _ := dataMap[first]

				switch curVal.(type) {
				case map[string]interface{}:
				default:
					dataMap[first] = make(map[string]interface{})
					curVal, _ = dataMap[first]
				}
				//  <--------|

				dataMap[first] = DeepSet(dataMap[first], rest, value)
				return dataMap
			}
		}
	}

	return data
}