         .map { (self, $0) }
         return ensureValidPeripheralState(observable)
     }
+
+    private func shouldBeIdentifierIncluded(identifier: CBUUID, forIdentifiers identifiers: [CBUUID]?) -> Bool {
+        if let identifiers = identifiers {
+            return identifiers.contains(identifier)
+        }
+        return true
+    }
 }
 
 extension Peripheral: Equatable {

     - Parameter service: The service whose included services you want to discover.
     - Returns: Returns array of included discovered services.
     */
    public func discoverIncludedServices(includedServiceUUIDs: [CBUUID], forService service: Service) -> Observable<[Service]> {
        let observable = peripheral.rx_didDiscoverIncludedServicesForService
        .flatMap{ (service, error) -> Observable<[Service]> in
            if let includedServices = service.includedServices where error == nil {
                let services = includedServices
                .filter { includedServiceUUIDs.isEmpty || includedServiceUUIDs.contains($0.uuid) }
                .map { Service(peripheral: self, service: $0) }
                return Observable.just(services)
            }
            return Observable.error(BluetoothError.IncludedServicesDiscoveryFailed(self, error))
        }
        return Observable.deferred {
            self.peripheral.discoverIncludedServices(includedServiceUUIDs.isEmpty ? nil : includedServiceUUIDs, forService: service.service)
            return self.ensureValidPeripheralState(observable)
        }
    }

    - Parameter identifiers: Identifiers of wanted characteristics
    - Returns: Stream of characteristics
    */
    public func discoverCharacteristics(identifiers: [CBUUID]?, service: Service) -> Observable<[Characteristic]> {
        let observable = peripheral.rx_didDiscoverCharacteristicsForService
        .flatMap { (cbService, error) -> Observable<[Characteristic]> in
            if let characteristics = cbService.characteristics where error == nil {
                let filtered = characteristics
                .filter { self.shouldBeIdentifierIncluded($0.uuid, forIdentifiers: identifiers) }
                .map { Characteristic(characteristic: $0, service: service) }
                return Observable.just(filtered)
            }
            return Observable.error(BluetoothError.CharacteristicsDiscoveryFailed(service, error))
        }
        return Observable.deferred {
            self.peripheral.discoverCharacteristics(identifiers, forService: service.service)
            return self.ensureValidPeripheralState(observable)
        }
    }
