Packages
ranged_int

2.0.1
2.0.1 2.0.0 1.0.0
Type safe ranged integer operations for Gleam.
HexDocs
Current section
Files
Jump to
Readme 3 Versions 2 Dependencies Dependants Files Activity
ranged_int src ranged_int@builtin@generic.erl
Raw
src/ranged_int@builtin@generic.erl

-module(ranged_int@builtin@generic).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/ranged_int/builtin/generic.gleam").
-export([to_bigint/1, get_interface/1, compare/2, absolute/1, add/2, subtract/2, multiply/2, divide/2, divide_no_zero/2, modulo/2, modulo_no_zero/2, remainder/2, remainder_no_zero/2, power/2, overflow/2, eject/2, from_bigint_overflowable/3, from_bigint_min/2, from_bigint_max/2]).
-export_type([generic_interface/1, ranged_int/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

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

-opaque generic_interface(EFM) :: {generic_interface,
        ranged_int@interface:interface(ranged_int(EFM), EFM)}.

-opaque ranged_int(EFN) :: {ranged_int,
        bigi:big_int(),
        fun(() -> ranged_int@interface:interface(ranged_int(EFN), EFN))}.

-file("src/ranged_int/builtin/generic.gleam", 46).
-spec to_bigint(ranged_int(any())) -> bigi:big_int().
to_bigint(Int) ->
    erlang:element(2, Int).

-file("src/ranged_int/builtin/generic.gleam", 52).
?DOC(
    " Get the interface of the integer. This interface is required for `overflow`\n"
    " and `eject`.\n"
).
-spec get_interface(ranged_int(EFU)) -> generic_interface(EFU).
get_interface(Int) ->
    {generic_interface, (erlang:element(3, Int))()}.

-file("src/ranged_int/builtin/generic.gleam", 56).
-spec compare(ranged_int(EFX), ranged_int(EFX)) -> gleam@order:order().
compare(A, B) ->
    ranged_int@interface:compare(A, B, (erlang:element(3, A))()).

-file("src/ranged_int/builtin/generic.gleam", 60).
-spec absolute(ranged_int(EGB)) -> {ok, ranged_int(EGB)} |
    {error, ranged_int@utils:overflow()}.
absolute(A) ->
    ranged_int@interface:math_op_unary(
        A,
        (erlang:element(3, A))(),
        fun erlang:abs/1
    ).

-file("src/ranged_int/builtin/generic.gleam", 64).
-spec add(ranged_int(EGE), bigi:big_int()) -> {ok, ranged_int(EGE)} |
    {error, ranged_int@utils:overflow()}.
add(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:add/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 68).
-spec subtract(ranged_int(EGH), bigi:big_int()) -> {ok, ranged_int(EGH)} |
    {error, ranged_int@utils:overflow()}.
subtract(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:subtract/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 72).
-spec multiply(ranged_int(EGK), bigi:big_int()) -> {ok, ranged_int(EGK)} |
    {error, ranged_int@utils:overflow()}.
multiply(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:multiply/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 76).
-spec divide(ranged_int(EGN), bigi:big_int()) -> {ok, ranged_int(EGN)} |
    {error, ranged_int@utils:overflow()}.
divide(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:divide/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 80).
-spec divide_no_zero(ranged_int(EGQ), bigi:big_int()) -> {ok,
        {ok, ranged_int(EGQ)} | {error, ranged_int@utils:overflow()}} |
    {error, nil}.
divide_no_zero(A, B) ->
    ranged_int@interface:fallible_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:divide_no_zero/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 84).
-spec modulo(ranged_int(EGT), bigi:big_int()) -> {ok, ranged_int(EGT)} |
    {error, ranged_int@utils:overflow()}.
modulo(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:modulo/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 88).
-spec modulo_no_zero(ranged_int(EGW), bigi:big_int()) -> {ok,
        {ok, ranged_int(EGW)} | {error, ranged_int@utils:overflow()}} |
    {error, nil}.
modulo_no_zero(A, B) ->
    ranged_int@interface:fallible_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:modulo_no_zero/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 92).
-spec remainder(ranged_int(EGZ), bigi:big_int()) -> {ok, ranged_int(EGZ)} |
    {error, ranged_int@utils:overflow()}.
remainder(A, B) ->
    ranged_int@interface:math_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:remainder/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 96).
-spec remainder_no_zero(ranged_int(EHC), bigi:big_int()) -> {ok,
        {ok, ranged_int(EHC)} | {error, ranged_int@utils:overflow()}} |
    {error, nil}.
remainder_no_zero(A, B) ->
    ranged_int@interface:fallible_op(
        A,
        B,
        (erlang:element(3, A))(),
        fun bigi_ffi:remainder_no_zero/2
    ).

-file("src/ranged_int/builtin/generic.gleam", 100).
-spec power(ranged_int(EHF), ranged_int@builtin@uint:uint()) -> {ok,
        ranged_int(EHF)} |
    {error, ranged_int@utils:overflow()}.
power(A, B) ->
    Result@1 = case ranged_int@interface:fallible_op(
        A,
        ranged_int@builtin@uint:to_bigint(B),
        (erlang:element(3, A))(),
        fun bigi_ffi:power/2
    ) of
        {ok, Result} -> Result;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"ranged_int/builtin/generic"/utf8>>,
                        function => <<"power"/utf8>>,
                        line => 101,
                        value => _assert_fail,
                        start => 3203,
                        'end' => 3301,
                        pattern_start => 3214,
                        pattern_end => 3224})
    end,
    Result@1.

-file("src/ranged_int/builtin/generic.gleam", 106).
-spec overflow(
    {ok, ranged_int(ranged_int@interface:overflowable())} |
        {error, ranged_int@utils:overflow()},
    generic_interface(ranged_int@interface:overflowable())
) -> ranged_int(ranged_int@interface:overflowable()).
overflow(Op, Interface) ->
    ranged_int@interface:overflow(Op, erlang:element(2, Interface)).

-file("src/ranged_int/builtin/generic.gleam", 113).
-spec eject(
    {ok, ranged_int(EHM)} | {error, ranged_int@utils:overflow()},
    generic_interface(EHM)
) -> bigi:big_int().
eject(Op, Interface) ->
    ranged_int@interface:eject(Op, erlang:element(2, Interface)).

-file("src/ranged_int/builtin/generic.gleam", 120).
-spec gen_overflowable_interface(bigi:big_int(), bigi:big_int()) -> ranged_int@interface:interface(ranged_int(ranged_int@interface:overflowable()), ranged_int@interface:overflowable()).
gen_overflowable_interface(Min, Max) ->
    {interface,
        fun to_bigint/1,
        fun(B) ->
            {ranged_int, B, fun() -> gen_overflowable_interface(Min, Max) end}
        end,
        fun() -> ranged_int@interface:overflowable_limits(Min, Max) end}.

-file("src/ranged_int/builtin/generic.gleam", 29).
?DOC(
    " Create from a big integer and a minimum and maximum value, both inclusive.\n"
    " The created integer can be used with `overflow`.\n"
).
-spec from_bigint_overflowable(bigi:big_int(), bigi:big_int(), bigi:big_int()) -> {ok,
        ranged_int(ranged_int@interface:overflowable())} |
    {error, ranged_int@utils:overflow()}.
from_bigint_overflowable(Value, Min, Max) ->
    Iface = gen_overflowable_interface(Min, Max),
    ranged_int@interface:from_bigint(Value, Iface).

-file("src/ranged_int/builtin/generic.gleam", 132).
-spec gen_min_interface(bigi:big_int()) -> ranged_int@interface:interface(ranged_int(ranged_int@interface:non_overflowable()), ranged_int@interface:non_overflowable()).
gen_min_interface(Min) ->
    {interface,
        fun to_bigint/1,
        fun(B) -> {ranged_int, B, fun() -> gen_min_interface(Min) end} end,
        fun() -> ranged_int@interface:min_limit(Min) end}.

-file("src/ranged_int/builtin/generic.gleam", 35).
?DOC(" Create from a big integer and a minimum value, inclusive.\n").
-spec from_bigint_min(bigi:big_int(), bigi:big_int()) -> {ok,
        ranged_int(ranged_int@interface:non_overflowable())} |
    {error, ranged_int@utils:overflow()}.
from_bigint_min(Value, Min) ->
    Iface = gen_min_interface(Min),
    ranged_int@interface:from_bigint(Value, Iface).

-file("src/ranged_int/builtin/generic.gleam", 142).
-spec gen_max_interface(bigi:big_int()) -> ranged_int@interface:interface(ranged_int(ranged_int@interface:non_overflowable()), ranged_int@interface:non_overflowable()).
gen_max_interface(Max) ->
    {interface,
        fun to_bigint/1,
        fun(B) -> {ranged_int, B, fun() -> gen_max_interface(Max) end} end,
        fun() -> ranged_int@interface:max_limit(Max) end}.

-file("src/ranged_int/builtin/generic.gleam", 41).
?DOC(" Create from a big integer and a maximum value, inclusive.\n").
-spec from_bigint_max(bigi:big_int(), bigi:big_int()) -> {ok,
        ranged_int(ranged_int@interface:non_overflowable())} |
    {error, ranged_int@utils:overflow()}.
from_bigint_max(Value, Max) ->
    Iface = gen_max_interface(Max),
    ranged_int@interface:from_bigint(Value, Iface).
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT