mooncakes.io

README

wqbcs/moon_collections/bitmask does not have a README file

#
BitFlags

pub struct BitFlags {
  bits : UInt64
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl BitAnd for BitFlags

impl BitOr for BitFlags

impl BitXOr for BitFlags

impl Collection for BitFlags

impl Deterministic for BitFlags

#
BitFlags::all

source

fn BitFlags::all() -> BitFlags

#
BitFlags::bits

source

fn BitFlags::bits(self : BitFlags) -> UInt64

#
BitFlags::clear_all

source

fn BitFlags::clear_all(_self : BitFlags) -> BitFlags

#
BitFlags::complement

source

fn BitFlags::complement(self : BitFlags) -> BitFlags

#
BitFlags::contains

source

fn BitFlags::contains(self : BitFlags, flag : UInt64) -> Bool

#
BitFlags::count_ones

source

fn BitFlags::count_ones(self : BitFlags) -> Int

#
BitFlags::count_zeros

source

fn BitFlags::count_zeros(self : BitFlags) -> Int

#
BitFlags::difference

source

fn BitFlags::difference(self : BitFlags, other : BitFlags) -> BitFlags

#
BitFlags::from_bits

source

fn BitFlags::from_bits(bits : UInt64) -> BitFlags

#
BitFlags::insert

source

fn BitFlags::insert(self : BitFlags, flag : UInt64) -> BitFlags

#
BitFlags::intersect

source

fn BitFlags::intersect(self : BitFlags, other : BitFlags) -> BitFlags

#
BitFlags::intersects

source

fn BitFlags::intersects(self : BitFlags, other : BitFlags) -> Bool

#
BitFlags::is_disjoint

source

fn BitFlags::is_disjoint(self : BitFlags, other : BitFlags) -> Bool

#
BitFlags::is_empty

source

fn BitFlags::is_empty(self : BitFlags) -> Bool

#
BitFlags::is_subset

source

fn BitFlags::is_subset(self : BitFlags, other : BitFlags) -> Bool

#
BitFlags::is_superset

source

fn BitFlags::is_superset(self : BitFlags, other : BitFlags) -> Bool

#
BitFlags::len

source

fn BitFlags::len(self : BitFlags) -> Int

#
BitFlags::new

source

fn BitFlags::new() -> BitFlags

#
BitFlags::none

source

fn BitFlags::none() -> BitFlags

#
BitFlags::remove

source

fn BitFlags::remove(self : BitFlags, flag : UInt64) -> BitFlags

#
BitFlags::set_all

source

fn BitFlags::set_all(_self : BitFlags) -> BitFlags

#
BitFlags::symmetric_difference

source

fn BitFlags::symmetric_difference(self : BitFlags, other : BitFlags) -> BitFlags

#
BitFlags::to_bit_string

source

fn BitFlags::to_bit_string(self : BitFlags) -> String

#
BitFlags::toggle

source

fn BitFlags::toggle(self : BitFlags, flag : UInt64) -> BitFlags

#
BitFlags::union

source

fn BitFlags::union(self : BitFlags, other : BitFlags) -> BitFlags

#
BitSet

source

pub struct BitSet {
  bits : Array[UInt64]
  len : Int
  fp_cache : UInt64
  fp_dirty : Bool
}

impl Eq for BitSet

impl Debug for BitSet

impl Collection for BitSet

impl Deterministic for BitSet

#
BitSet::all_set

source

fn BitSet::all_set(self : BitSet) -> Bool

#
BitSet::any

source

fn BitSet::any(self : BitSet) -> Bool

#
BitSet::capacity

source

fn BitSet::capacity(self : BitSet) -> Int

#
BitSet::clear

source

fn BitSet::clear(self : BitSet, index : Int) -> Unit

#
BitSet::clear_all

source

fn BitSet::clear_all(self : BitSet) -> Unit

#
BitSet::clone

source

fn BitSet::clone(self : BitSet) -> BitSet

#
BitSet::complement

source

fn BitSet::complement(self : BitSet) -> BitSet

#
BitSet::contains

source

fn BitSet::contains(self : BitSet, index : Int) -> Bool

#
BitSet::count_ones

source

fn BitSet::count_ones(self : BitSet) -> Int

#
BitSet::count_zeros

source

fn BitSet::count_zeros(self : BitSet) -> Int

#
BitSet::difference

source

fn BitSet::difference(self : BitSet, other : BitSet) -> BitSet

#
BitSet::difference_with

source

fn BitSet::difference_with(self : BitSet, other : BitSet) -> Unit

#
BitSet::extend_

source

fn BitSet::extend_(self : BitSet, additional : Int) -> Unit

#
BitSet::first_one

source

fn BitSet::first_one(self : BitSet) -> Int?

#
BitSet::first_zero

source

fn BitSet::first_zero(self : BitSet) -> Int?

#
BitSet::from_indices

source

fn BitSet::from_indices(indices : Array[Int]) -> BitSet

#
BitSet::intersect

source

fn BitSet::intersect(self : BitSet, other : BitSet) -> BitSet

#
BitSet::intersect_with

source

fn BitSet::intersect_with(self : BitSet, other : BitSet) -> Unit

#
BitSet::is_disjoint

source

fn BitSet::is_disjoint(self : BitSet, other : BitSet) -> Bool

#
BitSet::is_empty

source

fn BitSet::is_empty(self : BitSet) -> Bool

#
BitSet::is_strict_subset

source

fn BitSet::is_strict_subset(self : BitSet, other : BitSet) -> Bool

#
BitSet::is_subset

source

fn BitSet::is_subset(self : BitSet, other : BitSet) -> Bool

#
BitSet::is_superset

source

fn BitSet::is_superset(self : BitSet, other : BitSet) -> Bool

#
BitSet::iter_ones

source

fn BitSet::iter_ones(self : BitSet) -> Iter[Int]

#
BitSet::iter_zeros

source

fn BitSet::iter_zeros(self : BitSet) -> Iter[Int]

#
BitSet::last_one

source

fn BitSet::last_one(self : BitSet) -> Int?

#
BitSet::last_zero

source

fn BitSet::last_zero(self : BitSet) -> Int?

#
BitSet::length

source

fn BitSet::length(self : BitSet) -> Int

#
BitSet::new

source

fn BitSet::new(capacity : Int) -> BitSet

#
BitSet::next_one

source

fn BitSet::next_one(self : BitSet, from : Int) -> Int?

#
BitSet::none

source

fn BitSet::none() -> BitSet

#
BitSet::prev_one

source

fn BitSet::prev_one(self : BitSet, from : Int) -> Int?

#
BitSet::resize

source

fn BitSet::resize(self : BitSet, new_len : Int) -> Unit

#
BitSet::set

source

fn BitSet::set(self : BitSet, index : Int) -> Unit

#
BitSet::set_all

source

fn BitSet::set_all(self : BitSet) -> Unit

#
BitSet::symmetric_difference

source

fn BitSet::symmetric_difference(self : BitSet, other : BitSet) -> BitSet

#
BitSet::to_bit_string

source

fn BitSet::to_bit_string(self : BitSet) -> String

#
BitSet::to_indices

source

fn BitSet::to_indices(self : BitSet) -> Array[Int]

#
BitSet::toggle

source

fn BitSet::toggle(self : BitSet, index : Int) -> Unit

#
BitSet::truncate

source

fn BitSet::truncate(self : BitSet, new_len : Int) -> Unit

#
BitSet::union

source

fn BitSet::union(self : BitSet, other : BitSet) -> BitSet

#
BitSet::union_with

source

fn BitSet::union_with(self : BitSet, other : BitSet) -> Unit

Source Files

Install

moon add wqbcs/moon_collections@0.2.4

Download zip

DETERMINISTIC × VERIFIABLE × COMPOSABLE collections for MoonBit/WASM — 12 ordered structures, FNV-1a fingerprints with lazy caching (all 11 Deterministic structs), 311 tests. Same input → same output → same fingerprint, always.

collectionsindexmapbitsetbitflagscounterdefault-mapdeterministicdata-structuremoonbitwasmwasm-gcfingerprintringbuffersparse-setsorted-mapdisjoint-setordered-mapverifiablecomposableecs

wqbcs

0.2.4

Apache-2.0

github.com/wqbcs/moon_collections

Updated last month

15 downloads

Site source Report issue Packages Build queue Skills Statistics

#BitFlags

#BitFlags::all

#BitFlags::bits

#BitFlags::clear_all

#BitFlags::complement

#BitFlags::contains

#BitFlags::count_ones

#BitFlags::count_zeros

#BitFlags::difference

#BitFlags::from_bits

#BitFlags::insert

#BitFlags::intersect

#BitFlags::intersects

#BitFlags::is_disjoint

#BitFlags::is_empty

#BitFlags::is_subset

#BitFlags::is_superset

#BitFlags::len

#BitFlags::new

#BitFlags::none

#BitFlags::remove

#BitFlags::set_all

#BitFlags::symmetric_difference

#BitFlags::to_bit_string

#BitFlags::toggle

#BitFlags::union

#BitSet

#BitSet::all_set

#BitSet::any

#BitSet::capacity

#BitSet::clear

#BitSet::clear_all

#BitSet::clone

#BitSet::complement

#BitSet::contains

#BitSet::count_ones

#BitSet::count_zeros

#BitSet::difference

#BitSet::difference_with

#BitSet::extend_

#BitSet::first_one

#BitSet::first_zero

#BitSet::from_indices

#BitSet::intersect

#BitSet::intersect_with

#BitSet::is_disjoint

#BitSet::is_empty

#BitSet::is_strict_subset

#BitSet::is_subset

#BitSet::is_superset

#BitSet::iter_ones

#BitSet::iter_zeros

#BitSet::last_one

#BitSet::last_zero

#BitSet::length

#BitSet::new

#BitSet::next_one

#BitSet::none

#BitSet::prev_one

#BitSet::resize

#BitSet::set

#BitSet::set_all

#BitSet::symmetric_difference

#BitSet::to_bit_string

#BitSet::to_indices

#BitSet::toggle

#BitSet::truncate

#BitSet::union

#BitSet::union_with

Source Files

#
BitFlags

#
BitFlags::all

#
BitFlags::bits

#
BitFlags::clear_all

#
BitFlags::complement

#
BitFlags::contains

#
BitFlags::count_ones

#
BitFlags::count_zeros

#
BitFlags::difference

#
BitFlags::from_bits

#
BitFlags::insert

#
BitFlags::intersect

#
BitFlags::intersects

#
BitFlags::is_disjoint

#
BitFlags::is_empty

#
BitFlags::is_subset

#
BitFlags::is_superset

#
BitFlags::len

#
BitFlags::new

#
BitFlags::none

#
BitFlags::remove

#
BitFlags::set_all

#
BitFlags::symmetric_difference

#
BitFlags::to_bit_string

#
BitFlags::toggle

#
BitFlags::union

#
BitSet

#
BitSet::all_set

#
BitSet::any

#
BitSet::capacity

#
BitSet::clear

#
BitSet::clear_all

#
BitSet::clone

#
BitSet::complement

#
BitSet::contains

#
BitSet::count_ones

#
BitSet::count_zeros

#
BitSet::difference

#
BitSet::difference_with

#
BitSet::extend_

#
BitSet::first_one

#
BitSet::first_zero

#
BitSet::from_indices

#
BitSet::intersect

#
BitSet::intersect_with

#
BitSet::is_disjoint

#
BitSet::is_empty

#
BitSet::is_strict_subset

#
BitSet::is_subset

#
BitSet::is_superset

#
BitSet::iter_ones

#
BitSet::iter_zeros

#
BitSet::last_one

#
BitSet::last_zero

#
BitSet::length

#
BitSet::new

#
BitSet::next_one

#
BitSet::none

#
BitSet::prev_one

#
BitSet::resize

#
BitSet::set

#
BitSet::set_all

#
BitSet::symmetric_difference

#
BitSet::to_bit_string

#
BitSet::to_indices

#
BitSet::toggle

#
BitSet::truncate

#
BitSet::union

#
BitSet::union_with