# inplace v0.7.1 - Table of Contents

Mutable data structures

## Modules

- [InPlace.Array](InPlace.Array.md)
- [InPlace.BitSet](InPlace.BitSet.md): BitSet is close in functionality to MapSet with integer values as members.
The main difference is that BitSet has lower and upper bounds
for set values that have to be defined at the time of creation (see new/2).

- [InPlace.BitUtils](InPlace.BitUtils.md)
- [InPlace.Common](InPlace.Common.md)
- [InPlace.ExactCover](InPlace.ExactCover.md): Implementation of Exact Cover.
Based on https://arxiv.org/pdf/cs/0011047 by Donald Knuth.
Modified to use "dancing cells" instead of "dancing links"
for Dancing cells, see
YouTube: "Stanford Lecture: Dr. Don Knuth - Dancing Cells (2023)"

- [InPlace.Examples.Josephus](InPlace.Examples.Josephus.md): https://en.wikipedia.org/wiki/Josephus_problem

- [InPlace.Examples.Sudoku](InPlace.Examples.Sudoku.md): Sudoku puzzle.
The instance of puzzle is a string of DxD length
, where D is a dimension of Sudoku puzzle (would be 9 by default).
The values 1 to 9 represent pre-filled cells (clues, givens etc...);
any other values represent hidden cells.

- [InPlace.Heap](InPlace.Heap.md): Binary heap.
NOTE:
- The heap keys are limited to integers.
- The capacity of the heap has to be specified at the time of creation.

- [InPlace.HeapSort](InPlace.HeapSort.md)
- [InPlace.LinkedList](InPlace.LinkedList.md): [Singly linked list](https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list)
The data entries are stored as integers.
They will be interpreted (as references) by the calling application.
Note: indices are 1-based.
Options:
  - `mode` :: :singly_linked | :doubly_linked
  - `circular` :: boolean()
    optional, `false` by default;
  - `deletion` :: :reclaim | :hide | :rewind
    Handles if the element pointer could be restored later (see delete_pointer/2), and how
    to restore it:
    `:reclaim` (default) - element can not be restored, the pointer will be put back to the `allocation` pool;
    `:hide` - element can be restored by re-linking with it's former `left` and `right` neighbors;
     The element stays in the list, but can not be reached
     except by directly addressed by it's pointer. The element can be put back to it's position
     by reconnecting previously prior and next elements back to that element (see hide/2 and restore/2);
    `:rewind` - if specified, the special stack of removed element pointers is maintained.
      The effect of removal will be the same as for  :hide, except that
      The elements can be restored in the reverse order of their removal by using `rewind/1`.
  - `:mapper_fun`  # maps data entries to application data
    optional, &Function.identity/1 by default

- [InPlace.PriorityQueue](InPlace.PriorityQueue.md)
- [InPlace.Queue](InPlace.Queue.md)
- [InPlace.SparseSet](InPlace.SparseSet.md):   Sparse set implementation based on
  https://youtu.be/PUJ_XdmSDZw?si=41ySCBvOdoNCV-zR
- [InPlace.Stack](InPlace.Stack.md)