title: Getting `conform to 'LosslessStringConvertible` error
body: <p>So im trying to sort out an issue here. I have this data model object, and I am getting back from an endpoint, an array of [ContentItem.ContentID] types, in another class to what im showing in the bottom. I want to convert that array to an array of [String], but i am getting the following error:
  <code>Cannot convert value of type '[ContentItem.ContentID]' to expected argument type '[String]'</code></p>
  
  <p>When I try to FlatMap it to a String, I get:
  <code>Initializer 'init(_:)' requires that '[ContentItem.ContentID]' conform to 'LosslessStringConvertible'</code></p>
  
  <p>I get an error saying I need the following data model to conform to  <code>LosslessStringConvertible</code> but im not sure how. </p>
  
  <pre class="lang-swift prettyprint-override"><code>
  
  import Foundation
  
  struct ContentItem: Codable, Equatable {
      enum ContentID: Codable {
          case text(String)
          case number(Int)
  
          case empty
      }
      enum SeriesID: Codable {
          case text(String)
          case number(Int)
  
          case empty
      }
  
      enum CodingKeys: String, CodingKey {
          case contentID = "content_id"
          case seriesID = "series_id"
          case rank = "rank"
          case score = "score"
      }
  
      init(from decoder: Decoder) throws {
          let values = try decoder.container(keyedBy: CodingKeys.self)
          rank = try values.decode(Int.self, forKey: .rank)
          score = try values.decode(Float.self, forKey: .score)
          seriesID = try values.decode(SeriesID.self, forKey: .seriesID)
          contentID = try values.decode(ContentID.self, forKey: .contentID)
      }
  
      func encode(to encoder: Encoder) throws {
          var container = encoder.container(keyedBy: CodingKeys.self)
          try container.encode(score, forKey: .score)
          try container.encode(rank, forKey: .rank)
          try container.encode(seriesID, forKey: .seriesID)
          try container.encode(contentID, forKey: .contentID)
      }
  
      let rank: Int
      let score: Float
      let seriesID: SeriesID
      let contentID: ContentID
  
  }
  
  extension ContentItem.SeriesID: Equatable, Hashable {
  
      func encode(to encoder: Encoder) throws {
          var container = encoder.singleValueContainer()
          switch self {
          case .text(let text):
              try container.encode(text)
          case .number(let number):
              try container.encode(number)
          case .empty:
              break
          }
      }
  
      public func hash(into hasher: inout Hasher) {
          hasher.combine(self.hashValue)
      }
  
      init(from decoder: Decoder) throws {
          let container = try decoder.singleValueContainer()
          if let text = try? container.decode(String.self) {
              self = .text(text)
          } else if let number = try? container.decode(Int.self) {
              self = .number(number)
          } else {
              //assertionFailure("Unknown id type")
              self = .empty
          }
      }
  
  }
  
  extension ContentItem.ContentID: Equatable, Hashable {
  
      func encode(to encoder: Encoder) throws {
          var container = encoder.singleValueContainer()
          switch self {
          case .text(let text):
              try container.encode(text)
          case .number(let number):
              try container.encode(number)
          case .empty:
              break
          }
      }
  
      public func hash(into hasher: inout Hasher) {
          hasher.combine(self.hashValue)
      }
  
      init(from decoder: Decoder) throws {
          let container = try decoder.singleValueContainer()
          if let text = try? container.decode(String.self) {
              self = .text(text)
          } else if let number = try? container.decode(Int.self) {
              self = .number(number)
          } else {
  //            assertionFailure("Unknown id type")
              self = .empty
          }
      }
  
  }
  
  </code></pre>
  
  <p>The class calling it, containing the error is:</p>
  
  <pre><code>...
  func GET(endpoint: Endpoint, params: [String: String]?) -&gt; AnyPublisher&lt;[ContentItem.ContentID], APIError&gt; {
  
          guard let token = self.apiKey else {
              fatalError("Missing Credentials. Please add a valid Samba token")
          }
  
          var request = generaterURLRequest(endpoint: endpoint, params: params)
          request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
  
          return URLSession.shared
              .dataTaskPublisher(for: request)
              .receive(on: apiQueue)
              .map(\.data)
              .decode(type: PaginatedResponse&lt;ContentItem&gt;.self, decoder: JSONDecoder() )
              .mapError { error -&gt; APIError in
                  switch error {
                      case is URLError:
                          return APIError.urlError(error as! URLError)
                      case is DecodingError:
                          return APIError.decodingError(error as! DecodingError)
                      default:
                          return APIError.genericError(error as! DecodingError)
                      }
              }
              .map {$0.results.map { String($0.contentID)}}
              .filter { !$0.isEmpty }
              .eraseToAnyPublisher()
      }
  ...
  </code></pre>
  
  <p>Any help would be greatly appreciated. </p>
  
  <p>Thanks</p>