pubgrub - v1.0.0

pubgrub

Types

Dependencies

</> 
pub type Dependencies(p, v, m) {
  Unavailable(m)
  Available(dict.Dict(p, version_ranges.Ranges(v)))
}

Constructors

DependencyProvider

</> 
pub type DependencyProvider(p, v, m, err, priority) {
  DependencyProvider(
    compare: fn(v, v) -> order.Order,
    compare_priority: fn(priority, priority) -> order.Order,
    prioritize: fn(
      p,
      version_ranges.Ranges(v),
      PackageResolutionStatistics,
    ) -> priority,
    choose_version: fn(p, version_ranges.Ranges(v)) -> Result(
      option.Option(v),
      err,
    ),
    get_dependencies: fn(p, v) -> Result(
      Dependencies(p, v, m),
      err,
    ),
    should_cancel: fn() -> Result(Nil, err),
  )
}

Constructors

OfflineDependencyProvider

</> 
pub type OfflineDependencyProvider(p, v) {
  OfflineDependencyProvider(
    dependencies: dict.Dict(
      p,
      dict.Dict(v, dict.Dict(p, version_ranges.Ranges(v))),
    ),
  )
}

Constructors

PackageResolutionStatistics

</> 
pub type PackageResolutionStatistics {
  PackageResolutionStatistics(
    unit_propagation_affected: Int,
    unit_propagation_culprit: Int,
    dependencies_affected: Int,
    dependencies_culprit: Int,
  )
}

Constructors 

  • PackageResolutionStatistics(
  unit_propagation_affected: Int,
  unit_propagation_culprit: Int,
  dependencies_affected: Int,
  dependencies_culprit: Int,
)

PubGrubError

</> 
pub type PubGrubError(p, v, m, err) {
  NoSolution(report.DerivationTree(p, v, m))
  ErrorRetrievingDependencies(
    package: p,
    version: v,
    source: err,
  )
  ErrorChoosingVersion(package: p, source: err)
  ErrorInShouldCancel(source: err)
}

Constructors 

  • NoSolution(report.DerivationTree(p, v, m))
  • ErrorRetrievingDependencies(package: p, version: v, source: err)
  • ErrorChoosingVersion(package: p, source: err)
  • ErrorInShouldCancel(source: err)

SemanticVersion

</> 
pub type SemanticVersion =
  #(Int, Int, Int)

Values

conflict_count

</> 
pub fn conflict_count(stats: PackageResolutionStatistics) -> Int

empty_stats

</> 
pub fn empty_stats() -> PackageResolutionStatistics

offline_add_dependencies

</> 
pub fn offline_add_dependencies(
  provider: OfflineDependencyProvider(p, v),
  package: p,
  version: v,
  dependencies: List(#(p, version_ranges.Ranges(v))),
) -> OfflineDependencyProvider(p, v)

offline_new

</> 
pub fn offline_new() -> OfflineDependencyProvider(p, v)

offline_packages

</> 
pub fn offline_packages(
  provider: OfflineDependencyProvider(p, v),
) -> List(p)

offline_provider

</> 
pub fn offline_provider(
  provider: OfflineDependencyProvider(p, v),
  compare: fn(v, v) -> order.Order,
) -> DependencyProvider(p, v, String, Nil, #(Int, Int))

offline_versions

</> 
pub fn offline_versions(
  provider: OfflineDependencyProvider(p, v),
  package: p,
) -> option.Option(List(v))

resolve

</> 
pub fn resolve(
  dependency_provider: DependencyProvider(p, v, m, err, priority),
  package: p,
  version: v,
) -> Result(dict.Dict(p, v), PubGrubError(p, v, m, err))

semantic_version_new

</> 
pub fn semantic_version_new(
  major: Int,
  minor: Int,
  patch: Int,
) -> #(Int, Int, Int)

semantic_version_to_string

</> 
pub fn semantic_version_to_string(
  ver: #(Int, Int, Int),
) -> String
✨ Search Document