202 	var j int

   202 

   203 	// TODO: Would be better to compare dates and merge chronologically...

   203 	// Sort method: isLater returns true if mi's date is later or

   204 	for _, nItem := range newItems {

   204 	// equal to mj's date.

   205 		result = append(result, nItem)

   205 	isLater := func(mi, mj measurement) bool {

   206 		if j+1 <= len(oldItems) && nItem == oldItems[j] {

   206 		switch {

   207 			j++

   207 		case mi.Year < mj.Year:

   208 		}

   208 			return false

   209 	}

   209 		case mi.Year > mj.Year:

   210 	if j+1 <= len(oldItems) {

   210 			return true

   211 		result = append(result, oldItems[j:]...)

   211 		case mi.Month < mj.Month:

   212 			return false

   213 		case mi.Month > mj.Month:

   214 			return true

   215 		case mi.Day < mj.Day:

   216 			return false

   217 		case mi.Day > mj.Day:

   218 			return true

   219 		case mi.Hour < mj.Hour:

   220 			return false

   221 		case mi.Hour > mj.Hour:

   222 			return true

   223 		case mi.Minute < mj.Minute:

   224 			return false

   225 		default:

   226 			return true

   227 		}

   228 	}

   229 

   230 	sort.Slice(oldItems, func(i, j int) bool {

   231 		return isLater(oldItems[i], oldItems[j])

   232 	})

   233 	sort.Slice(newItems, func(i, j int) bool {

   234 		return isLater(newItems[i], newItems[j])

   235 	})

   236 

   237 	appendIfMissing := func(l []measurement, m measurement) []measurement {

   238 		var i int

   239 		for i = range l {

   240 			if !isLater(l[i], m) {

   241 				break

   242 			}

   243 			if l[i] == m { // Duplicate

   244 				return l

   245 			}

   246 		}

   247 		if i == len(l) {

   248 			return append(l[:i], m)

   249 		}

   250 		r := append(l[:i], append(l[i:], m)...)

   251 		return r

   252 	}

   253 

   254 	for _, item := range newItems {

   255 		result = appendIfMissing(result, item)

   256 	}

   257 	for _, item := range oldItems {

   258 		result = appendIfMissing(result, item)