generic

A generic ranged integer.

This module is meant for cases where the integer range cannot be known at compile time. Generic ranged integers are less type safe and have lower performance. It’s always suggested to use one of the builtin types or to create your own type when you can.

Types

GenericInterface

</>

The interface of a generic ranged integer.

pub opaque type GenericInterface(overflow_mode)

RangedInt

</>

A generic ranged integer, carrying its own interface along with the data.

pub opaque type RangedInt(overflow_mode)

Functions

absolute

</>

pub fn absolute(
  a: RangedInt(a),
) -> Result(RangedInt(a), Overflow)

add

</>

pub fn add(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

compare

</>

pub fn compare(a: RangedInt(a), b: RangedInt(a)) -> Order

divide

</>

pub fn divide(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

divide_no_zero

</>

pub fn divide_no_zero(
  a: RangedInt(a),
  b: BigInt,
) -> Result(Result(RangedInt(a), Overflow), Nil)

eject

</>

pub fn eject(
  op: Result(RangedInt(a), Overflow),
  interface: GenericInterface(a),
) -> BigInt

from_bigint_max

</>

pub fn from_bigint_max(
  value: BigInt,
  max max: BigInt,
) -> Result(RangedInt(NonOverflowable), Overflow)

Create from a big integer and a maximum value, inclusive.

from_bigint_min

</>

pub fn from_bigint_min(
  value: BigInt,
  min min: BigInt,
) -> Result(RangedInt(NonOverflowable), Overflow)

Create from a big integer and a minimum value, inclusive.

from_bigint_overflowable

</>

pub fn from_bigint_overflowable(
  value: BigInt,
  min min: BigInt,
  max max: BigInt,
) -> Result(RangedInt(Overflowable), Overflow)

Create from a big integer and a minimum and maximum value, both inclusive. The created integer can be used with overflow.

get_interface

</>

pub fn get_interface(int: RangedInt(a)) -> GenericInterface(a)

Get the interface of the integer. This interface is required for overflow and eject.

modulo

</>

pub fn modulo(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

modulo_no_zero

</>

pub fn modulo_no_zero(
  a: RangedInt(a),
  b: BigInt,
) -> Result(Result(RangedInt(a), Overflow), Nil)

multiply

</>

pub fn multiply(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

overflow

</>

pub fn overflow(
  op: Result(RangedInt(Overflowable), Overflow),
  interface: GenericInterface(Overflowable),
) -> RangedInt(Overflowable)

power

</>

pub fn power(
  a: RangedInt(a),
  b: Uint,
) -> Result(RangedInt(a), Overflow)

remainder

</>

pub fn remainder(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

remainder_no_zero

</>

pub fn remainder_no_zero(
  a: RangedInt(a),
  b: BigInt,
) -> Result(Result(RangedInt(a), Overflow), Nil)

subtract

</>

pub fn subtract(
  a: RangedInt(a),
  b: BigInt,
) -> Result(RangedInt(a), Overflow)

to_bigint

</>

pub fn to_bigint(int: RangedInt(a)) -> BigInt