mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-17 18:33:58 +00:00
ec20b1ed0a
NEWS:
Mention all the user-visible changes below.
library/enum.m:
Add the typeclass uenum, which is a version of the existing enum typeclass
that maps items to uints, not ints. It also uses a semidet predicate,
not a semidet function, to get back to the item from the uint.
library/sparse_bitset.m:
library/fat_sparse_bitset.m:
Make these modules operate on uints, which means requiring the items
in the sets to be instances of uenum, not enum.
If a few places, improve loops by doing previously-repeated conversions
of [u]ints into <offset, bit-to-set> pairs just once.
library/counter.m:
Define ucounters, which allocate uints. Improve documentation.
library/digraph.m:
Change digraph_keys from ints to uints, since we put them into
sparse_bitsets.
library/int.m:
Make int an instance of the uenum typeclass. This can help users
who currently put ints into sparse_bitsets.
library/pprint.m:
Prettyprint sparse_bitsets as lists of uints.
library/term.m:
Make vars instances of uenum as well as enum.
library/uint.m:
Make uint an instance of the uenum typeclass.
Add the ubits_per_uint function, which allows some casts to be avoided.
compiler/make.deps_set.m:
Change the indexes we put into sparse_bitsets from ints to uints.
compiler/make.make_info.m:
Change the source of those indexes from ints to uints.
compiler/make.top_level.m:
compiler/make.util.m:
Conform to the changes above.
compiler/pre_quantification.m:
Change zones from ints to uints, since we put them into sparse_bitsets.
tests/hard_coded/int_uenum.{m,exp}:
tests/hard_coded/Mmakefile:
Enable the new test case.
tests/valid/use_import_only_for_instance.m:
Update this extract from library/digraph.m the same way as
library/digraph.m itself.
97 lines
2.9 KiB
Mathematica
97 lines
2.9 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 2000, 2005-2006, 2011 The University of Melbourne.
|
|
% Copyright (C) 2014-2016, 2018 The Mercury team.
|
|
% This file is distributed under the terms specified in COPYING.LIB.
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% File: counter.m.
|
|
% Author: zs.
|
|
% Stability: high.
|
|
%
|
|
% Predicates for dealing with counters, which are mechanisms for allocating
|
|
% consecutively numbered integers. The abstraction barrier eliminates the
|
|
% possibility of confusion along the lines of "does this counter record
|
|
% the next number to be handed out, or the last number that was handed out?".
|
|
%
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module counter.
|
|
:- interface.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type counter.
|
|
|
|
% init(N) = Counter:
|
|
% init(N, Counter):
|
|
%
|
|
% Return in Counter a counter whose first allocation will be
|
|
% the integer N.
|
|
%
|
|
:- func init(int) = counter.
|
|
:- pred init(int::in, counter::out) is det.
|
|
|
|
% allocate(N, Counter0, Counter) takes a counter, and returns
|
|
%
|
|
% - the next integer to be allocated from that counter, and
|
|
% - the updated state of the counter.
|
|
%
|
|
:- pred allocate(int::out, counter::in, counter::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type ucounter.
|
|
|
|
% uinit(N) = Counter:
|
|
% uinit(N, Counter):
|
|
%
|
|
% Return in Counter a counter whose first allocation will be
|
|
% the unsigned integer N.
|
|
%
|
|
:- func uinit(uint) = ucounter.
|
|
:- pred uinit(uint::in, ucounter::out) is det.
|
|
|
|
% uallocate(N, Counter0, Counter) takes a counter, and returns
|
|
%
|
|
% - the next unsigned integer to be allocated from that counter, and
|
|
% - the updated state of the counter.
|
|
%
|
|
:- pred uallocate(uint::out, ucounter::in, ucounter::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module int.
|
|
:- import_module uint.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type counter
|
|
---> counter(int).
|
|
|
|
init(N) = counter(N).
|
|
|
|
init(N, counter(N)).
|
|
|
|
allocate(N, counter(N), counter(N + 1)).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type ucounter
|
|
---> ucounter(uint).
|
|
|
|
uinit(N) = ucounter(N).
|
|
|
|
uinit(N, ucounter(N)).
|
|
|
|
uallocate(N, ucounter(N), ucounter(N + 1u)).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
:- end_module counter.
|
|
%---------------------------------------------------------------------------%
|