code: func diffListsOfScalars(original, modified []interface{}) ([]interface{}, error) {
  	if len(modified) == 0 {
  		// There is no need to check the length of original because there is no way to create
  		// a patch that deletes a scalar from a list of scalars with merge semantics.
  		return nil, nil
  	}
  
  	patch := []interface{}{}
  
  	originalScalars := uniqifyAndSortScalars(original)
  	modifiedScalars := uniqifyAndSortScalars(modified)
  	originalIndex, modifiedIndex := 0, 0
  
  loopB:
  	for ; modifiedIndex < len(modifiedScalars); modifiedIndex++ {
  		for ; originalIndex < len(originalScalars); originalIndex++ {
  			originalString := fmt.Sprintf("%v", original[originalIndex])
  			modifiedString := fmt.Sprintf("%v", modified[modifiedIndex])
  			if originalString >= modifiedString {
  				if originalString != modifiedString {
  					patch = append(patch, modified[modifiedIndex])
  				}
  
  				continue loopB
  			}
  			// There is no else clause because there is no way to create a patch that deletes
  			// a scalar from a list of scalars with merge semantics.
  		}
  
  		break
  	}
  
  	// Add any remaining items found only in modified
  	for ; modifiedIndex < len(modifiedScalars); modifiedIndex++ {
  		patch = append(patch, modified[modifiedIndex])
  	}
  
  	return patch, nil
  }
docs: // Returns a (recursive) strategic merge patch that yields modified when applied to original,
  // for a pair of lists of scalars with merge semantics.