code: public final <R> Stream<R> transform(final Class<R> type, final boolean lenient,
              final Object... path) {
          synchronized (this.state) {
              checkState();
              return concat(new TransformPathStream<T, R>(this, type, lenient, path));
          }
      }
docs: Intermediate operation returning a Stream with the elements obtained by applying an
  optional <i>navigation path</i> and conversion to a certain type to the elements of this
  Stream. The path is a sequence of keys ({@code String}s, {@code URI}s, generic objects)
  that are applied to {@code Record}, {@code BindingSet}, {@code Map} and {@code Multimap}
  elements to extract child elements in a recursive fashion. Starting from an element
  returned by this stream, the result of this navigation process is a list of (sub-)child
  elements that are converted to the requested type (via {@link Data#convert(Object, Class)})
  and concatenated in the resulting stream; {@code Iterable}s, {@code Iterator}s and arrays
  found during the navigation are exploded and their elements individually considered. The
  {@code lenient} parameters controls whether conversion errors should be ignored or result
  in an exception being thrown by the returned Stream.
  
  @param type
  the class resulting elements should be converted to
  @param lenient
  true if conversion errors should be ignored
  @param path
  a vararg array of zero or more keys that recursively select the elements to
  return
  @param <R>
  the type of resulting elements
  @return a Stream over the elements obtained applying the navigation path and the conversion
  specified