&& Objects.equals(d1.getArtifactId(), d2.getArtifactId())
                && Objects.equals(d1.getVersion(), d2.getVersion())
                && Objects.equals(d1.getType(), d2.getType())
                && Objects.equals(d1.getClassifier(), d2.getClassifier())
                && Objects.equals(d1.getScope(), d2.getScope())
                && Objects.equals(d1.getSystemPath(), d2.getSystemPath())

        }

        @Override
        public String getId() {
            return descriptor.getName();
        }

        @Override
        public String getType() {
            return descriptor.getType().name();
        }

        @Override
        public String getName() {
            return descriptor.getName();
        }

        @Override

    // can have smaller memory usage.
    auto input_type =
        mlir::dyn_cast<RankedTensorType>(dequantize_op.getOutput().getType());
    auto output_type = mlir::dyn_cast<RankedTensorType>(
        passthrough_op->getResult(0).getType());
    if (!input_type || !output_type ||
        get_num_elements(input_type) <= get_num_elements(output_type)) {
      return failure();
    }

          <code>
            <![CDATA[
    /**
     * Computes a hash value based on {@link #getType()} and {@link #getProvides()} values.
     */
    public int hashCode() {
        return java.util.Objects.hash(getType(), getProvides());
    } //-- int hashCode()

    /**
     * Checks equality based on {@link #getType()} and {@link #getProvides()} values.
     */
    public boolean equals(Object other) {

    };

    // TODO extract common stuff from this and ModelSet and reuse

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(type)) {
            if (!type.getRawClass().equals(ModelMap.class)) {

    }

    @Override
    protected String toStringNoReentrance() {
        return String.format("or(%s, %s)", left, right);
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return left.getType();
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, left, right);

        modelType = new ModelType<ModelSet<?>>() {
        };
    }

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (modelType.isAssignableFrom(type)) {
            if (!type.getRawClass().equals(ModelSet.class)) {
                extractionContext.add(String.format("subtyping %s is not supported", ModelSet.class.getName()));

        }
    }

    @Override
    protected <R, S> ExtractedModelRule buildRule(ModelPath modelPath, MethodRuleDefinition<R, S> ruleDefinition) {
        ModelType<S> modelType = ruleDefinition.getSubjectReference().getType();
        final ModelSchema<S> modelSchema = getModelSchema(modelType, ruleDefinition);
        return new ExtractedManagedCreationRule<R, S>(modelPath, ruleDefinition, modelSchema);
    }

                                        ArrayRef<Attribute> operands) {
  auto lhs_type = mlir::cast<ShapedType>(arithmetic_op.getX().getType());
  auto rhs_type = mlir::cast<ShapedType>(arithmetic_op.getY().getType());
  auto result_type =
      mlir::cast<ShapedType>(arithmetic_op.getResult().getType());

  // We can fold arithmetic operation only of we can prove that we will not
  // accidentally hide a broadcasting error.

    protected DefaultToolchain(ToolchainModel model, String type, Logger logger) {
        this(model, logger);
        this.type = type;
    }

    @Override
    public final String getType() {
        return type != null ? type : model.getType();
    }

    @Override
    public final ToolchainModel getModel() {
        return model;
    }

    public final void addProvideToken(String type, RequirementMatcher matcher) {