#MoonBit H3

#Implemented Features

#Safe H3 cell index handling

• parse one to sixteen hexadecimal digits
• validate the complete 64-bit H3 cell layout
• reject invalid active digits and invalid unused digits
• enforce the deleted subsequence rule for pentagonal base cells
• inspect resolution, base cell, index digits, and pentagon status
• emit a canonical lower-case hexadecimal index

#Cell hierarchy operations

• calculate an ancestor at a requested resolution
• calculate the center descendant at a requested resolution
• test whether one cell is an ancestor or descendant of another

#Coordinate conversion

• decode an H3 cell center to decimal latitude and longitude
• encode decimal latitude and longitude as the containing H3 cell
• handle face-edge overages and pentagonal cells
• expose coordinates through a typed LatLng value

#Neighbor traversal

• query all cells within a grid_disk radius
• return cells in increasing distance order without duplicates
• handle face crossings and pentagonal deletions
• bound the radius to prevent unbounded memory growth
• query a neighbor in a specific H3 direction
• test adjacency and find the direction between neighboring cells
• query only the outer ring at an exact distance
• query every cell together with its grid distance

#Resolution metrics

• calculate the total number of cells at a resolution
• query the official average cell area in square kilometers
• query the official average edge length in kilometers
• calculate the great-circle distance between two cell centers
• calculate exact grid distance within the bounded search radius

#Installation

moon add LC6543/h3@0.10.1

#Usage

///|
test {
  let index = @h3.H3Index::parse("8928308280fffff").unwrap()
  assert_eq(index.resolution(), 9)
  assert_eq(index.base_cell(), 20)
  assert_eq(index.parent(7).unwrap().to_string(), "872830828ffffff")
  let center = index.to_lat_lng()
  assert_true(center.latitude().is_close(37.77670234943567))
  assert_true(center.longitude().is_close(-122.41845932318309))
  let same_cell = @h3.H3Index::from_lat_lng(
    37.77670234943567, -122.41845932318309, 9,
  ).unwrap()
  assert_eq(same_cell.to_string(), "8928308280fffff")
  assert_eq(index.grid_disk(1).unwrap().length(), 7)
  let neighbor = @h3.H3Index::parse("89283082803ffff").unwrap()
  assert_true(index.is_neighbor_of(neighbor))
  assert_eq(index.grid_ring(1).unwrap().length(), 6)
  assert_eq(index.grid_disk_distances(1).unwrap().length(), 7)
  assert_eq(@h3.resolution_cell_count(9).unwrap(), 4842432842UL)
  assert_true(index.great_circle_distance_km(neighbor).is_close(0.3547928245))
  assert_eq(index.grid_distance_to(neighbor).unwrap(), 1)
  assert_eq(index.to_string(), "8928308280fffff")
}

match @h3.H3Index::parse("8928308280zzfff") {
  Ok(index) => println(index.to_string())
  Err(InvalidCharacter(ch)) => println("invalid character: \{ch}")
  Err(_) => println("invalid H3 index")
}

#Runnable Example

moon run examples/basic

#Development

moon check --target all
moon build --target all
moon test --target all
moon check --fmt
moon package

#License