🥮 mooncakes.io

    mooncidr

    MoonCIDR provides IP address parsing, CIDR matching, and network range utilities for MoonBit.

    cidr
    ip
    ipv4
    ipv6
    network
    Download zip
    Author
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    30

    No dependencies

    #MoonCIDR

    MoonCIDR is a focused MoonBit MVP for IP/CIDR based access control.

    It targets one concrete need: services, API gateways, CLI tools, and edge workers often need to parse IP addresses, normalize CIDR blocks, evaluate allow/deny rules, and explain why a source address was accepted or rejected. MoonCIDR provides that core workflow with tests and a runnable example.

    #MVP Scope

    • Parse and format IPv4 addresses.
    • Parse and normalize IPv4 CIDR networks.
    • Check address, network, and range containment.
    • Classify IPv4 addresses: private, loopback, link-local, multicast, documentation, CGNAT, benchmark, reserved, broadcast, unspecified, and public.
    • Build IPv4 ranges and merge adjacent or overlapping ranges.
    • Build an ACL policy with ordered allow/deny rules.
    • Parse a small ACL text format such as allow net 10.0.0.0/8 office.
    • Evaluate a batch of IPv4 addresses and report allowed/denied counts.
    • Diagnose duplicate, covered, and overlapping networks.
    • Provide basic IPv6 address and CIDR parsing for compatibility checks.

    #Quick Start

    Clone the public repository and validate the project from source:

    git clone https://github.com/lzh123411/21341.git
cd 21341
moon check --deny-warn
moon test --deny-warn
moon run cmd/main

    ## Example

let policy = AclPolicy::deny_by_default()
  .deny_address("quarantine", Ipv4Address::parse("10.0.0.13").unwrap())
  .allow_network("office", Ipv4Network::parse("10.0.0.0/8").unwrap())

let result = policy.evaluate(Ipv4Address::parse("10.0.0.42").unwrap())
println(result.to_string())

    Run the included example:

    moon run cmd/main

    #ACL Text Format

    Policies use one rule per line:

    # deny exceptions must appear before a broad allow
deny host 10.0.0.13 quarantine
allow net 10.0.0.0/8 office
allow range 192.168.1.10 192.168.1.20 workers

    Rules are evaluated from top to bottom and the first matching rule wins. Blank lines and lines beginning with # are ignored.

    #Validation

    moon check --deny-warn
moon test --deny-warn
moon fmt --check
moon info

    The test suite covers parsing failures, CIDR normalization, network endpoints, scope classification, range behavior, ACL rule ordering, ACL text parsing, network-set matching, batch scan reports, diagnostics, IPv4 summarization, and basic IPv6 parsing.

    #Operational Boundaries

    • ACL text rules currently accept IPv4 addresses, ranges, and CIDR networks.
    • IPv6 supports full and ::-compressed addresses, but not IPv4-embedded notation or zone identifiers.
    • Network sets use deterministic linear matching and target small or medium gateway policies rather than Internet-scale routing tables.
    • Scope labels are diagnostic helpers, not authorization rules. Security decisions should use an explicit deny-by-default ACL policy.

    #Source and AI Assistance

    MoonCIDR is an original MoonBit implementation based on public Internet standards including RFC 4632, RFC 4291, RFC 4193, RFC 5737, and RFC 6598. It includes no copied third-party source code, runtime dependency, or external test fixture. AI assisted development, review, and test design; the contestant remains responsible for every API, implementation choice, and test result.

    #Project Records

    #License

    Apache-2.0

    AclBatchReport

    source
    pub struct AclBatchReport {
      allowed : Int
      denied : Int
      lines : Array[String]
    } derive(
    Debug    )

    AclBatchReport::allowed

    source
    fn AclBatchReport::allowed(self : AclBatchReport) -> Int

    AclBatchReport::denied

    source
    fn AclBatchReport::denied(self : AclBatchReport) -> Int

    AclBatchReport::lines

    source
    fn AclBatchReport::lines(self : AclBatchReport) -> Array[String]

    AclBatchReport::to_string

    source
    fn AclBatchReport::to_string(self : AclBatchReport) -> String

    AclDecision

    source
    pub enum AclDecision {
      Allow
      Deny
    } derive(Eq, 
    Debug    )

    AclDecision::allow

    source
    fn AclDecision::allow() -> AclDecision

    AclDecision::deny

    source
    fn AclDecision::deny() -> AclDecision

    AclDecision::to_string

    source
    fn AclDecision::to_string(self : AclDecision) -> String

    AclEvaluation

    source
    pub struct AclEvaluation {
      address : Ipv4Address
      decision : AclDecision
      matched_rule : String?
    } derive(Eq, 
    Debug    )

    AclEvaluation::decision

    source
    fn AclEvaluation::decision(self : AclEvaluation) -> AclDecision

    AclEvaluation::matched_rule

    source
    fn AclEvaluation::matched_rule(self : AclEvaluation) -> String?

    AclEvaluation::to_string

    source
    fn AclEvaluation::to_string(self : AclEvaluation) -> String

    AclParseError

    source
    pub struct AclParseError {
      line : Int
      input : String
      kind : AclParseKind
    } derive(Eq, 
    Debug    )

    AclParseError::to_string

    source
    fn AclParseError::to_string(self : AclParseError) -> String

    AclParseKind

    source
    pub enum AclParseKind {
      EmptyLine
      UnknownDecision
      UnknownTarget
      MissingField
      InvalidAddress
      InvalidNetwork
      InvalidRange
    } derive(Eq, 
    Debug    )

    AclParseKind::to_string

    source
    fn AclParseKind::to_string(self : AclParseKind) -> String

    AclPolicy

    source
    pub struct AclPolicy {
      rules : Array[AclRule]
      default_decision : AclDecision
    } derive(
    Debug    )

    AclPolicy::allow_address

    source
    fn AclPolicy::allow_address(self : AclPolicy, name : String, address : Ipv4Address) -> AclPolicy

    AclPolicy::allow_by_default

    source
    fn AclPolicy::allow_by_default() -> AclPolicy

    AclPolicy::allow_network

    source
    fn AclPolicy::allow_network(self : AclPolicy, name : String, network : Ipv4Network) -> AclPolicy

    AclPolicy::allow_range

    source
    fn AclPolicy::allow_range(self : AclPolicy, name : String, range : Ipv4Range) -> AclPolicy

    AclPolicy::allows

    source
    fn AclPolicy::allows(self : AclPolicy, address : Ipv4Address) -> Bool

    AclPolicy::deny_address

    source
    fn AclPolicy::deny_address(self : AclPolicy, name : String, address : Ipv4Address) -> AclPolicy

    AclPolicy::deny_by_default

    source
    fn AclPolicy::deny_by_default() -> AclPolicy

    AclPolicy::deny_network

    source
    fn AclPolicy::deny_network(self : AclPolicy, name : String, network : Ipv4Network) -> AclPolicy

    AclPolicy::deny_range

    source
    fn AclPolicy::deny_range(self : AclPolicy, name : String, range : Ipv4Range) -> AclPolicy

    AclPolicy::evaluate

    source
    fn AclPolicy::evaluate(self : AclPolicy, address : Ipv4Address) -> AclEvaluation

    AclPolicy::evaluate_many

    source
    fn AclPolicy::evaluate_many(self : AclPolicy, addresses : Array[Ipv4Address]) -> AclBatchReport

    AclPolicy::len

    source
    fn AclPolicy::len(self : AclPolicy) -> Int

    AclPolicy::new

    source
    fn AclPolicy::new(default_decision : AclDecision) -> AclPolicy

    AclPolicy::parse_lines

    source
    fn AclPolicy::parse_lines(lines : Array[String], default_decision : AclDecision) -> Result[AclPolicy, AclParseError]

    AclPolicy::push

    source
    fn AclPolicy::push(self : AclPolicy, rule : AclRule) -> AclPolicy

    AclRule

    source
    pub struct AclRule {
      name : String
      decision : AclDecision
      target : AclTarget
    } derive(Eq, 
    Debug    )

    AclRule::address

    source
    fn AclRule::address(name : String, decision : AclDecision, address : Ipv4Address) -> AclRule

    AclRule::decision

    source
    fn AclRule::decision(self : AclRule) -> AclDecision

    AclRule::explain

    source
    fn AclRule::explain(self : AclRule) -> String

    AclRule::matches

    source
    fn AclRule::matches(self : AclRule, address : Ipv4Address) -> Bool

    AclRule::name

    source
    fn AclRule::name(self : AclRule) -> String

    AclRule::network

    source
    fn AclRule::network(name : String, decision : AclDecision, network : Ipv4Network) -> AclRule

    AclRule::parse_line

    source
    fn AclRule::parse_line(line : String) -> Result[AclRule, AclParseError]

    AclRule::range

    source
    fn AclRule::range(name : String, decision : AclDecision, range : Ipv4Range) -> AclRule

    AclRule::target

    source
    fn AclRule::target(self : AclRule) -> AclTarget

    AclTarget

    source
    pub enum AclTarget {
      Network(Ipv4Network)
      Range(Ipv4Range)
      Address(Ipv4Address)
    } derive(Eq, 
    Debug    )

    AclTarget::matches

    source
    fn AclTarget::matches(self : AclTarget, address : Ipv4Address) -> Bool

    AclTarget::to_string

    source
    fn AclTarget::to_string(self : AclTarget) -> String

    AddressScanReport

    source
    pub struct AddressScanReport {
      total : Int
      allowed : Int
      denied : Int
      scope_counts : Array[ScopeCount]
      network_hits : Array[NetworkHit]
      unmatched : Array[Ipv4Address]
    } derive(
    Debug    )

    AddressScanReport::allowed

    source
    fn AddressScanReport::allowed(self : AddressScanReport) -> Int

    AddressScanReport::denied

    source
    fn AddressScanReport::denied(self : AddressScanReport) -> Int

    AddressScanReport::network_hits

    source

    AddressScanReport::scope_counts

    source

    AddressScanReport::to_string

    source
    fn AddressScanReport::to_string(self : AddressScanReport) -> String

    AddressScanReport::total

    source
    fn AddressScanReport::total(self : AddressScanReport) -> Int

    AddressScanReport::unmatched

    source

    CidrDiagnostic

    source
    pub struct CidrDiagnostic {
      severity : DiagnosticSeverity
      kind : DiagnosticKind
      message : String
    } derive(Eq, 
    Debug    )

    CidrDiagnostic::new

    source
    fn CidrDiagnostic::new(severity : DiagnosticSeverity, kind : DiagnosticKind, message : String) -> CidrDiagnostic

    CidrDiagnostic::to_string

    source
    fn CidrDiagnostic::to_string(self : CidrDiagnostic) -> String

    CidrError

    source
    pub enum CidrError {
      EmptyInput
      InvalidCharacter(String)
      InvalidOctetCount(Int)
      EmptyOctet(Int)
      OctetOutOfRange(Int, Int)
      InvalidPrefix(String)
      PrefixOutOfRange(Int)
      InvalidRange(String)
      TooManySubnets(Int)
    } derive(Eq, 
    Debug    )

    DiagnosticKind

    source
    pub enum DiagnosticKind {
      DuplicateNetwork
      CoveredNetwork
      OverlappingNetwork
      SpecialPurposeAddress
      EmptyPolicy
    } derive(Eq, 
    Debug    )

    DiagnosticKind::to_string

    source
    fn DiagnosticKind::to_string(self : DiagnosticKind) -> String

    DiagnosticReport

    source
    pub struct DiagnosticReport {
      diagnostics : Array[CidrDiagnostic]
    } derive(
    Debug    )

    DiagnosticReport::diagnostics

    source

    DiagnosticReport::error_count

    source
    fn DiagnosticReport::error_count(self : DiagnosticReport) -> Int

    DiagnosticReport::info_count

    source
    fn DiagnosticReport::info_count(self : DiagnosticReport) -> Int

    DiagnosticReport::is_empty

    source
    fn DiagnosticReport::is_empty(self : DiagnosticReport) -> Bool

    DiagnosticReport::len

    source
    fn DiagnosticReport::len(self : DiagnosticReport) -> Int

    DiagnosticReport::new

    source

    DiagnosticReport::push

    source

    DiagnosticReport::to_string

    source
    fn DiagnosticReport::to_string(self : DiagnosticReport) -> String

    DiagnosticReport::warning_count

    source
    fn DiagnosticReport::warning_count(self : DiagnosticReport) -> Int

    DiagnosticSeverity

    source
    pub enum DiagnosticSeverity {
      Info
      Warning
      Error
    } derive(Eq, 
    Debug    )

    DiagnosticSeverity::to_string

    source
    fn DiagnosticSeverity::to_string(self : DiagnosticSeverity) -> String

    Ipv4Address

    source
    pub struct Ipv4Address {
      value : UInt
    } derive(Compare, Eq, 
    Debug    )

    Ipv4Address::checked_add

    source
    fn Ipv4Address::checked_add(self : Ipv4Address, step : UInt) -> Ipv4Address?

    Ipv4Address::checked_sub

    source
    fn Ipv4Address::checked_sub(self : Ipv4Address, step : UInt) -> Ipv4Address?

    Ipv4Address::distance_to

    source
    fn Ipv4Address::distance_to(self : Ipv4Address, other : Ipv4Address) -> UInt

    Ipv4Address::from_octets

    source
    fn Ipv4Address::from_octets(a : Int, b : Int, c : Int, d : Int) -> Result[Ipv4Address, CidrError]

    Ipv4Address::from_uint

    source
    fn Ipv4Address::from_uint(value : UInt) -> Ipv4Address

    Ipv4Address::is_benchmark

    source
    fn Ipv4Address::is_benchmark(self : Ipv4Address) -> Bool

    Ipv4Address::is_carrier_grade_nat

    source
    fn Ipv4Address::is_carrier_grade_nat(self : Ipv4Address) -> Bool

    Ipv4Address::is_documentation

    source
    fn Ipv4Address::is_documentation(self : Ipv4Address) -> Bool

    Ipv4Address::is_global_unicast

    source
    fn Ipv4Address::is_global_unicast(self : Ipv4Address) -> Bool

    Ipv4Address::is_limited_broadcast

    source
    fn Ipv4Address::is_limited_broadcast(self : Ipv4Address) -> Bool

    fn Ipv4Address::is_link_local(self : Ipv4Address) -> Bool

    Ipv4Address::is_loopback

    source
    fn Ipv4Address::is_loopback(self : Ipv4Address) -> Bool

    Ipv4Address::is_multicast

    source
    fn Ipv4Address::is_multicast(self : Ipv4Address) -> Bool

    Ipv4Address::is_private

    source
    fn Ipv4Address::is_private(self : Ipv4Address) -> Bool

    Ipv4Address::is_reserved

    source
    fn Ipv4Address::is_reserved(self : Ipv4Address) -> Bool

    Ipv4Address::is_special_purpose

    source
    fn Ipv4Address::is_special_purpose(self : Ipv4Address) -> Bool

    Ipv4Address::is_unspecified

    source
    fn Ipv4Address::is_unspecified(self : Ipv4Address) -> Bool

    Ipv4Address::max

    source

    Ipv4Address::next

    source
    fn Ipv4Address::next(self : Ipv4Address) -> Ipv4Address?

    Ipv4Address::octet

    source
    fn Ipv4Address::octet(self : Ipv4Address, index : Int) -> Int

    Ipv4Address::parse

    source
    fn Ipv4Address::parse(input : String) -> Result[Ipv4Address, CidrError]

    Ipv4Address::previous

    source
    fn Ipv4Address::previous(self : Ipv4Address) -> Ipv4Address?

    Ipv4Address::scope

    source
    fn Ipv4Address::scope(self : Ipv4Address) -> Ipv4Scope

    Ipv4Address::to_string

    source
    fn Ipv4Address::to_string(self : Ipv4Address) -> String

    Ipv4Address::to_uint

    source
    fn Ipv4Address::to_uint(self : Ipv4Address) -> UInt

    Ipv4Address::zero

    source
    fn Ipv4Address::zero() -> Ipv4Address

    Ipv4Network

    source
    pub struct Ipv4Network {
      address : Ipv4Address
      prefix : Int
    } derive(Eq, 
    Debug    )

    Ipv4Network::address

    source
    fn Ipv4Network::address(self : Ipv4Network) -> Ipv4Address

    Ipv4Network::broadcast

    source
    fn Ipv4Network::broadcast(self : Ipv4Network) -> Ipv4Address

    Ipv4Network::contains

    source
    fn Ipv4Network::contains(self : Ipv4Network, address : Ipv4Address) -> Bool

    Ipv4Network::contains_network

    source
    fn Ipv4Network::contains_network(self : Ipv4Network, other : Ipv4Network) -> Bool

    Ipv4Network::contains_range

    source
    fn Ipv4Network::contains_range(self : Ipv4Network, range : Ipv4Range) -> Bool

    Ipv4Network::first

    source
    fn Ipv4Network::first(self : Ipv4Network) -> Ipv4Address

    Ipv4Network::from_address_and_netmask

    source
    fn Ipv4Network::from_address_and_netmask(address : Ipv4Address, mask : Ipv4Address) -> Result[Ipv4Network, CidrError]

    Ipv4Network::from_address_and_wildcard

    source
    fn Ipv4Network::from_address_and_wildcard(address : Ipv4Address, wildcard : Ipv4Address) -> Result[Ipv4Network, CidrError]

    Ipv4Network::host_count

    source
    fn Ipv4Network::host_count(self : Ipv4Network) -> UInt64

    Ipv4Network::is_adjacent_to

    source
    fn Ipv4Network::is_adjacent_to(self : Ipv4Network, other : Ipv4Network) -> Bool

    Ipv4Network::is_more_specific_than

    source
    fn Ipv4Network::is_more_specific_than(self : Ipv4Network, other : Ipv4Network) -> Bool

    Ipv4Network::last

    source
    fn Ipv4Network::last(self : Ipv4Network) -> Ipv4Address

    Ipv4Network::netmask

    source
    fn Ipv4Network::netmask(self : Ipv4Network) -> Ipv4Address

    Ipv4Network::new

    source
    fn Ipv4Network::new(address : Ipv4Address, prefix : Int) -> Result[Ipv4Network, CidrError]

    Ipv4Network::nth_subnet

    source
    fn Ipv4Network::nth_subnet(self : Ipv4Network, new_prefix : Int, index : Int) -> Result[Ipv4Network, CidrError]

    Ipv4Network::overlaps

    source
    fn Ipv4Network::overlaps(self : Ipv4Network, other : Ipv4Network) -> Bool

    Ipv4Network::parent

    source
    fn Ipv4Network::parent(self : Ipv4Network) -> Ipv4Network?

    Ipv4Network::parse

    source
    fn Ipv4Network::parse(input : String) -> Result[Ipv4Network, CidrError]

    Ipv4Network::prefix

    source
    fn Ipv4Network::prefix(self : Ipv4Network) -> Int

    Ipv4Network::scope

    source
    fn Ipv4Network::scope(self : Ipv4Network) -> Ipv4Scope

    Ipv4Network::sibling

    source
    fn Ipv4Network::sibling(self : Ipv4Network) -> Ipv4Network?

    Ipv4Network::split

    source
    fn Ipv4Network::split(self : Ipv4Network) -> Result[(Ipv4Network, Ipv4Network), CidrError]

    Ipv4Network::subnets

    source
    fn Ipv4Network::subnets(self : Ipv4Network, new_prefix : Int) -> Result[Array[Ipv4Network], CidrError]

    Ipv4Network::supernet

    source
    fn Ipv4Network::supernet(self : Ipv4Network, new_prefix : Int) -> Result[Ipv4Network, CidrError]

    Ipv4Network::to_cisco_wildcard

    source
    fn Ipv4Network::to_cisco_wildcard(self : Ipv4Network) -> String

    Ipv4Network::to_string

    source
    fn Ipv4Network::to_string(self : Ipv4Network) -> String

    Ipv4Network::usable_host_count

    source
    fn Ipv4Network::usable_host_count(self : Ipv4Network) -> UInt64

    Ipv4Network::wildcard_mask

    source
    fn Ipv4Network::wildcard_mask(self : Ipv4Network) -> Ipv4Address

    Ipv4NetworkSet

    source
    pub struct Ipv4NetworkSet {
      networks : Array[Ipv4Network]
    } derive(
    Debug    )

    Ipv4NetworkSet::contains

    source
    fn Ipv4NetworkSet::contains(self : Ipv4NetworkSet, address : Ipv4Address) -> Bool

    Ipv4NetworkSet::from_array

    source
    fn Ipv4NetworkSet::from_array(networks : Array[Ipv4Network]) -> Ipv4NetworkSet

    Ipv4NetworkSet::insert

    source
    fn Ipv4NetworkSet::insert(self : Ipv4NetworkSet, network : Ipv4Network) -> Ipv4NetworkSet

    Ipv4NetworkSet::is_covered

    source
    fn Ipv4NetworkSet::is_covered(self : Ipv4NetworkSet, network : Ipv4Network) -> Bool

    Ipv4NetworkSet::is_empty

    source
    fn Ipv4NetworkSet::is_empty(self : Ipv4NetworkSet) -> Bool

    Ipv4NetworkSet::len

    source
    fn Ipv4NetworkSet::len(self : Ipv4NetworkSet) -> Int

    Ipv4NetworkSet::match_network

    source
    fn Ipv4NetworkSet::match_network(self : Ipv4NetworkSet, address : Ipv4Address) -> Ipv4Network?

    Ipv4NetworkSet::new

    source

    Ipv4NetworkSet::parse_all

    source
    fn Ipv4NetworkSet::parse_all(items : Array[String]) -> Result[Ipv4NetworkSet, CidrError]

    Ipv4NetworkSet::to_array

    source

    Ipv4NetworkSet::to_string

    source
    fn Ipv4NetworkSet::to_string(self : Ipv4NetworkSet) -> String

    Ipv4Range

    source
    pub struct Ipv4Range {
      start : Ipv4Address
      end : Ipv4Address
    } derive(Eq, 
    Debug    )

    Ipv4Range::contains

    source
    fn Ipv4Range::contains(self : Ipv4Range, address : Ipv4Address) -> Bool

    Ipv4Range::contains_network

    source
    fn Ipv4Range::contains_network(self : Ipv4Range, network : Ipv4Network) -> Bool

    Ipv4Range::end

    source
    fn Ipv4Range::end(self : Ipv4Range) -> Ipv4Address

    Ipv4Range::from_network

    source
    fn Ipv4Range::from_network(network : Ipv4Network) -> Ipv4Range

    Ipv4Range::is_adjacent_to

    source
    fn Ipv4Range::is_adjacent_to(self : Ipv4Range, other : Ipv4Range) -> Bool

    Ipv4Range::merge

    source
    fn Ipv4Range::merge(self : Ipv4Range, other : Ipv4Range) -> Result[Ipv4Range, CidrError]

    Ipv4Range::new

    source
    fn Ipv4Range::new(start : Ipv4Address, end : Ipv4Address) -> Result[Ipv4Range, CidrError]

    Ipv4Range::overlaps

    source
    fn Ipv4Range::overlaps(self : Ipv4Range, other : Ipv4Range) -> Bool

    Ipv4Range::parse

    source
    fn Ipv4Range::parse(start : String, end : String) -> Result[Ipv4Range, CidrError]

    Ipv4Range::start

    source
    fn Ipv4Range::start(self : Ipv4Range) -> Ipv4Address

    Ipv4Range::to_string

    source
    fn Ipv4Range::to_string(self : Ipv4Range) -> String

    Ipv4Scope

    source
    pub enum Ipv4Scope {
      Private
      Loopback
      LinkLocal
      Multicast
      Documentation
      CarrierGradeNat
      Benchmark
      LimitedBroadcast
      Unspecified
      Reserved
      Public
    } derive(Eq, 
    Debug    )

    Ipv4Scope::documentation

    source
    fn Ipv4Scope::documentation() -> Ipv4Scope

    fn Ipv4Scope::link_local() -> Ipv4Scope

    Ipv4Scope::loopback

    source
    fn Ipv4Scope::loopback() -> Ipv4Scope

    Ipv4Scope::multicast

    source
    fn Ipv4Scope::multicast() -> Ipv4Scope

    Ipv4Scope::private

    source
    fn Ipv4Scope::private() -> Ipv4Scope

    Ipv4Scope::public

    source
    fn Ipv4Scope::public() -> Ipv4Scope

    Ipv4Scope::to_string

    source
    fn Ipv4Scope::to_string(self : Ipv4Scope) -> String

    Ipv4Summary

    source
    pub struct Ipv4Summary {
      networks : Array[Ipv4Network]
    } derive(
    Debug    )

    Ipv4Summary::contains

    source
    fn Ipv4Summary::contains(self : Ipv4Summary, address : Ipv4Address) -> Bool

    Ipv4Summary::from_addresses

    source
    fn Ipv4Summary::from_addresses(addresses : Array[Ipv4Address]) -> Ipv4Summary

    Ipv4Summary::from_networks

    source
    fn Ipv4Summary::from_networks(networks : Array[Ipv4Network]) -> Ipv4Summary

    Ipv4Summary::from_ranges

    source
    fn Ipv4Summary::from_ranges(ranges : Array[Ipv4Range]) -> Result[Ipv4Summary, CidrError]

    Ipv4Summary::len

    source
    fn Ipv4Summary::len(self : Ipv4Summary) -> Int

    Ipv4Summary::networks

    source
    fn Ipv4Summary::networks(self : Ipv4Summary) -> Array[Ipv4Network]

    Ipv4Summary::to_string

    source
    fn Ipv4Summary::to_string(self : Ipv4Summary) -> String

    Ipv6Address

    source
    pub struct Ipv6Address {
      hi : UInt64
      lo : UInt64
    } derive(Compare, Eq, 
    Debug    )

    Ipv6Address::from_segments

    source
    fn Ipv6Address::from_segments(s0 : Int, s1 : Int, s2 : Int, s3 : Int, s4 : Int, s5 : Int, s6 : Int, s7 : Int) -> Result[Ipv6Address, CidrError]

    Ipv6Address::is_documentation

    source
    fn Ipv6Address::is_documentation(self : Ipv6Address) -> Bool

    Ipv6Address::is_global_unicast

    source
    fn Ipv6Address::is_global_unicast(self : Ipv6Address) -> Bool

    fn Ipv6Address::is_link_local(self : Ipv6Address) -> Bool

    Ipv6Address::is_loopback

    source
    fn Ipv6Address::is_loopback(self : Ipv6Address) -> Bool

    Ipv6Address::is_multicast

    source
    fn Ipv6Address::is_multicast(self : Ipv6Address) -> Bool

    Ipv6Address::is_special_purpose

    source
    fn Ipv6Address::is_special_purpose(self : Ipv6Address) -> Bool

    Ipv6Address::is_unique_local

    source
    fn Ipv6Address::is_unique_local(self : Ipv6Address) -> Bool

    Ipv6Address::is_unspecified

    source
    fn Ipv6Address::is_unspecified(self : Ipv6Address) -> Bool

    Ipv6Address::mask

    source
    fn Ipv6Address::mask(self : Ipv6Address, prefix : Int) -> Ipv6Address

    Ipv6Address::parse

    source
    fn Ipv6Address::parse(input : String) -> Result[Ipv6Address, CidrError]

    Ipv6Address::scope

    source
    fn Ipv6Address::scope(self : Ipv6Address) -> Ipv6Scope

    Ipv6Address::segment

    source
    fn Ipv6Address::segment(self : Ipv6Address, index : Int) -> Int

    Ipv6Address::to_string

    source
    fn Ipv6Address::to_string(self : Ipv6Address) -> String

    Ipv6Network

    source
    pub struct Ipv6Network {
      address : Ipv6Address
      prefix : Int
    } derive(Eq, 
    Debug    )

    Ipv6Network::address

    source
    fn Ipv6Network::address(self : Ipv6Network) -> Ipv6Address

    Ipv6Network::contains

    source
    fn Ipv6Network::contains(self : Ipv6Network, address : Ipv6Address) -> Bool

    Ipv6Network::contains_network

    source
    fn Ipv6Network::contains_network(self : Ipv6Network, other : Ipv6Network) -> Bool

    Ipv6Network::new

    source
    fn Ipv6Network::new(address : Ipv6Address, prefix : Int) -> Result[Ipv6Network, CidrError]

    Ipv6Network::parse

    source
    fn Ipv6Network::parse(input : String) -> Result[Ipv6Network, CidrError]

    Ipv6Network::prefix

    source
    fn Ipv6Network::prefix(self : Ipv6Network) -> Int

    Ipv6Network::to_string

    source
    fn Ipv6Network::to_string(self : Ipv6Network) -> String

    Ipv6NetworkSet

    source
    pub struct Ipv6NetworkSet {
      networks : Array[Ipv6Network]
    } derive(
    Debug    )

    Ipv6NetworkSet::contains

    source
    fn Ipv6NetworkSet::contains(self : Ipv6NetworkSet, address : Ipv6Address) -> Bool

    Ipv6NetworkSet::from_array

    source
    fn Ipv6NetworkSet::from_array(networks : Array[Ipv6Network]) -> Ipv6NetworkSet

    Ipv6NetworkSet::insert

    source
    fn Ipv6NetworkSet::insert(self : Ipv6NetworkSet, network : Ipv6Network) -> Ipv6NetworkSet

    Ipv6NetworkSet::is_covered

    source
    fn Ipv6NetworkSet::is_covered(self : Ipv6NetworkSet, network : Ipv6Network) -> Bool

    Ipv6NetworkSet::len

    source
    fn Ipv6NetworkSet::len(self : Ipv6NetworkSet) -> Int

    Ipv6NetworkSet::match_network

    source
    fn Ipv6NetworkSet::match_network(self : Ipv6NetworkSet, address : Ipv6Address) -> Ipv6Network?

    Ipv6NetworkSet::new

    source

    Ipv6NetworkSet::parse_all

    source
    fn Ipv6NetworkSet::parse_all(items : Array[String]) -> Result[Ipv6NetworkSet, CidrError]

    Ipv6NetworkSet::to_array

    source

    Ipv6NetworkSet::to_string

    source
    fn Ipv6NetworkSet::to_string(self : Ipv6NetworkSet) -> String

    Ipv6Scope

    source
    pub enum Ipv6Scope {
      Unspecified6
      Loopback6
      Multicast6
      UniqueLocal6
      LinkLocal6
      Documentation6
      Global6
    } derive(Eq, 
    Debug    )

    Ipv6Scope::to_string

    source
    fn Ipv6Scope::to_string(self : Ipv6Scope) -> String

    NetworkHit

    source
    pub struct NetworkHit {
      network : Ipv4Network
      count : Int
    } derive(Eq, 
    Debug    )

    NetworkHit::count

    source
    fn NetworkHit::count(self : NetworkHit) -> Int

    NetworkHit::network

    source
    fn NetworkHit::network(self : NetworkHit) -> Ipv4Network

    NetworkHit::to_string

    source
    fn NetworkHit::to_string(self : NetworkHit) -> String

    ScopeCount

    source
    pub struct ScopeCount {
      scope : Ipv4Scope
      count : Int
    } derive(Eq, 
    Debug    )

    ScopeCount::count

    source
    fn ScopeCount::count(self : ScopeCount) -> Int

    ScopeCount::scope

    source
    fn ScopeCount::scope(self : ScopeCount) -> Ipv4Scope

    ScopeCount::to_string

    source
    fn ScopeCount::to_string(self : ScopeCount) -> String

    diagnose_acl

    source
    fn diagnose_acl(policy : AclPolicy) -> DiagnosticReport

    diagnose_addresses

    source
    fn diagnose_addresses(addresses : Array[Ipv4Address]) -> DiagnosticReport

    diagnose_networks

    source
    fn diagnose_networks(networks : Array[Ipv4Network]) -> DiagnosticReport

    filter_by_scope

    source
    fn filter_by_scope(addresses : Array[Ipv4Address], scope : Ipv4Scope) -> Array[Ipv4Address]

    filter_matching_set

    source
    fn filter_matching_set(addresses : Array[Ipv4Address], networks : Ipv4NetworkSet) -> Array[Ipv4Address]

    filter_not_matching_set

    source
    fn filter_not_matching_set(addresses : Array[Ipv4Address], networks : Ipv4NetworkSet) -> Array[Ipv4Address]

    parse_ipv4_addresses

    source
    fn parse_ipv4_addresses(items : Array[String]) -> Result[Array[Ipv4Address], CidrError]

    scan_addresses

    source
    fn scan_addresses(addresses : Array[Ipv4Address], policy : AclPolicy, networks : Ipv4NetworkSet) -> AddressScanReport

    summarize_addresses

    source
    fn summarize_addresses(addresses : Array[Ipv4Address]) -> Ipv4Summary

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io