Map<String, Node> nodes = node.stream()
                    .collect(Collectors.toMap(n -> getDependencyKey(n.getDependency()), Function.identity()));
            Map<String, Dependency> directDependencies = model.getDependencies().stream()
                    .filter(dependency -> !"import".equals(dependency.getScope()))
                    .collect(Collectors.toMap(
                            DefaultConsumerPomBuilder::getDependencyKey,

  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.apache.maven</groupId>
    <artifactId>maven-compat-modules</artifactId>
    <version>4.1.0-SNAPSHOT</version>
  </parent>

  <artifactId>maven-model</artifactId>

  <name>Maven Model</name>
  <description>Model for Maven POM (Project Object Model)</description>

    }

    public Map<MavenProject, ProjectSegment> selectSegment(TaskSegment taskSegment) {
        return items.stream()
                .filter(pb -> taskSegment == pb.getTaskSegment())
                .collect(Collectors.toMap(ProjectSegment::getProject, Function.identity()));
    }

    /**
     * Finds the first ProjectSegment matching the supplied project
     * @param mavenProject the requested project

                    .stream()
                    .filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();

     * System scope.
     */
    SYSTEM("system", false);

    private static final Map<String, DependencyScope> IDS = Collections.unmodifiableMap(
            Stream.of(DependencyScope.values()).collect(Collectors.toMap(s -> s.id, s -> s)));

    /**
     * {@return the dependency scope for the given identifier, or {@code null} if none}.
     * The identifiers are usually in lower cases with {@code '-'} instead of {@code '_'}

        return new Result<>(hasErrors(problems), model, problems);
    }

    /**
     * New result consisting of given result and new problem. Convenience for newResult(result.get(),
     * concat(result.getProblems(),problems)).
     *
     * @param result
     * @param problem
     */
    public static <T> Result<T> addProblem(Result<T> result, ModelProblem problem) {

        @Override
        public List<Lifecycle.Phase> phases() {
            return phases;
        }

        @Override
        public Stream<Lifecycle.Phase> allPhases() {
            return Stream.concat(Stream.of(this), phases().stream().flatMap(Lifecycle.Phase::allPhases));
        }
    }

    static class DefaultAlias implements Lifecycle.Alias {
        private final String v3Phase;

### Crear una dependencia, o "dependable" { #create-a-dependency-or-dependable }

Primero enfoquémonos en la dependencia.

Es solo una función que puede tomar todos los mismos parámetros que una *path operation function* puede tomar:

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}

Eso es todo.

**2 líneas**.

Y tiene la misma forma y estructura que todas tus *path operation functions*.

/** Benchmarks for memory consumption of map implementations. */
@NullUnmarked
public class MapsMemoryBenchmark {
  static final Map<String, MapsImplEnum> mapEnums =
      uniqueIndex(
          Iterables.<MapsImplEnum>concat(
              asList(MapImpl.values()), asList(SortedMapImpl.values()), asList(BiMapImpl.values())),
          toStringFunction());

  @Param({
    "HashMapImpl",
    "LinkedHashMapImpl",
    "ConcurrentHashMapImpl",

    console.log(pr_resp);
    throw `PR:{pr_number} needs to be valid and closed (merged)`;
  }
  const pr_title = pr_resp.data.title;
  // Assign to PR owner and reviewers
  const assignees = pr_resp.data.assignees.concat(pr_resp.data.requested_reviewers);
  let assignee_logins = assignees.map(x => x.login);
  assignee_logins.push(pr_resp.data.user.login);
  console.log(assignee_logins);
  // Create an new GH Issue and reference the Original PR