Repository: zhiburt/tabled
Pull request #475 (2025-01-08 14:09:07)

Refactorings


Patch:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ad2802d..6c0e7d6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -120,7 +120,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.66.0
+      - uses: dtolnay/rust-toolchain@1.83.0
       - run: cargo build --manifest-path=./tabled/Cargo.toml --all-features
 
   fmt:
diff --git a/json_to_table/src/table/collapsed_table.rs b/json_to_table/src/table/collapsed_table.rs
index 71ca47e..0aefd78 100644
--- a/json_to_table/src/table/collapsed_table.rs
+++ b/json_to_table/src/table/collapsed_table.rs
@@ -9,8 +9,6 @@ use tabled::{
     builder::Builder,
     grid::{
         config::{AlignmentHorizontal, AlignmentVertical, ColoredConfig, Entity, Offset},
-        dimension::{Dimension, Estimate},
-        records::Records,
         util::string::{count_lines, get_line_width, get_lines, get_text_dimension},
     },
     settings::{Padding, TableOption},
@@ -585,21 +583,6 @@ fn generate_value_cell(value: &str, cfg: &Config, ctx: PrintContext) -> CellData
     CellData::new(table, vec![ctx.size.width], vec![ctx.size.height])
 }
 
-#[allow(dead_code)]
-struct NoTopBorders;
-
-impl<R, D> TableOption<R, ColoredConfig, D> for NoTopBorders {
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        let mut borders = *cfg.get_borders();
-        borders.top = None;
-        borders.top_intersection = None;
-        borders.top_left = None;
-        borders.top_right = None;
-
-        cfg.set_borders(borders);
-    }
-}
-
 struct NoBottomBorders;
 
 impl<R, D> TableOption<R, ColoredConfig, D> for NoBottomBorders {
@@ -628,21 +611,6 @@ impl<R, D> TableOption<R, ColoredConfig, D> for NoRightBorders {
     }
 }
 
-#[allow(dead_code)]
-struct NoLeftBorders;
-
-impl<R, D> TableOption<R, ColoredConfig, D> for NoLeftBorders {
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        let mut borders = *cfg.get_borders();
-        borders.top_left = None;
-        borders.bottom_left = None;
-        borders.left = None;
-        borders.left_intersection = None;
-
-        cfg.set_borders(borders);
-    }
-}
-
 struct TopLeftChangeTopIntersection;
 
 impl<R, D> TableOption<R, ColoredConfig, D> for TopLeftChangeTopIntersection {
@@ -687,42 +655,6 @@ impl<R, D> TableOption<R, ColoredConfig, D> for TopRightChangeToRight {
     }
 }
 
-#[allow(dead_code)]
-struct BottomLeftChangeSplit;
-
-impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeSplit {
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        let mut borders = *cfg.get_borders();
-        borders.bottom_left = borders.left_intersection;
-
-        cfg.set_borders(borders);
-    }
-}
-
-#[allow(dead_code)]
-struct BottomLeftChangeSplitToIntersection;
-
-impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeSplitToIntersection {
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        let mut borders = *cfg.get_borders();
-        borders.bottom_left = borders.intersection;
-
-        cfg.set_borders(borders);
-    }
-}
-
-#[allow(dead_code)]
-struct BottomRightChangeToRight;
-
-impl<R, D> TableOption<R, ColoredConfig, D> for BottomRightChangeToRight {
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        let mut borders = *cfg.get_borders();
-        borders.bottom_right = borders.right_intersection;
-
-        cfg.set_borders(borders);
-    }
-}
-
 struct BottomLeftChangeToBottomIntersection;
 
 impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeToBottomIntersection {
@@ -734,38 +666,6 @@ impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeToBottomIntersec
     }
 }
 
-#[allow(dead_code)]
-struct SetBottomChars<'a>(&'a [usize], char);
-
-impl<R, D> TableOption<R, ColoredConfig, D> for SetBottomChars<'_>
-where
-    R: Records,
-    for<'a> &'a R: Records,
-    for<'a> D: Dimension + Estimate<&'a R, SpannedConfig>,
-{
-    fn change(self, records: &mut R, cfg: &mut ColoredConfig, dims: &mut D) {
-        dims.estimate(&*records, cfg);
-
-        let table_width = (0..records.count_columns())
-            .map(|col| dims.get_width(col))
-            .sum::<usize>()
-            + cfg.count_vertical(records.count_columns());
-        let mut current_width = 0;
-
-        for pos in self.0 {
-            current_width += pos;
-            if current_width > table_width {
-                break;
-            }
-
-            let split_char = self.1;
-            cfg.set_horizontal_char((1, 0), split_char, Offset::Begin(current_width));
-
-            current_width += 1;
-        }
-    }
-}
-
 struct SetTopChars<'a>(&'a [usize], char);
 
 impl<R, D> TableOption<R, ColoredConfig, D> for SetTopChars<'_> {
diff --git a/papergrid/examples/color_map.rs b/papergrid/examples/color_map.rs
index 2058d47..89f2434 100644
--- a/papergrid/examples/color_map.rs
+++ b/papergrid/examples/color_map.rs
@@ -18,10 +18,8 @@ use owo_colors::{
 
 use papergrid::{
     ansi::ANSIFmt,
-    config::spanned::SpannedConfig,
-    config::{Borders, Position},
-    dimension::spanned::SpannedGridDimension,
-    dimension::Estimate,
+    config::{pos, spanned::SpannedConfig, Borders, Position},
+    dimension::{spanned::SpannedGridDimension, Estimate},
     grid::iterable::Grid,
     records::IterRecords,
 };
@@ -45,8 +43,11 @@ fn main() {
 
 fn generate_colors() -> HashMap<Position, Style> {
     HashMap::from([
-        ((0, 0), Style(OStyle::default().bg::<Red>().fg::<Black>())),
-        ((1, 1), Style(OStyle::default().bg::<Blue>())),
+        (
+            pos(0, 0),
+            Style(OStyle::default().bg::<Red>().fg::<Black>()),
+        ),
+        (pos(1, 1), Style(OStyle::default().bg::<Blue>())),
     ])
 }
 
diff --git a/papergrid/examples/colored_border.rs b/papergrid/examples/colored_border.rs
index 74594c2..6ed3736 100644
--- a/papergrid/examples/colored_border.rs
+++ b/papergrid/examples/colored_border.rs
@@ -9,10 +9,11 @@
 use papergrid::{
     ansi::ANSIBuf,
     colors::NoColors,
-    config::spanned::SpannedConfig,
-    config::{AlignmentHorizontal, AlignmentVertical, Borders, Entity::Global, Indent, Sides},
-    dimension::spanned::SpannedGridDimension,
-    dimension::Estimate,
+    config::{
+        pos, spanned::SpannedConfig, AlignmentHorizontal, AlignmentVertical, Borders,
+        Entity::Global, Indent, Sides,
+    },
+    dimension::{spanned::SpannedGridDimension, Estimate},
     grid::iterable::Grid,
     records::IterRecords,
 };
@@ -55,8 +56,8 @@ fn generate_table_config() -> SpannedConfig {
 
     let mut cfg = SpannedConfig::default();
     cfg.set_borders(style);
-    cfg.set_column_span((1, 1), 3);
-    cfg.set_row_span((0, 0), 2);
+    cfg.set_column_span(pos(1, 1), 3);
+    cfg.set_row_span(pos(0, 0), 2);
     cfg.set_alignment_horizontal((1, 0).into(), AlignmentHorizontal::Center);
     cfg.set_alignment_vertical(Global, AlignmentVertical::Center);
     cfg.set_padding(
diff --git a/papergrid/examples/common_grid.rs b/papergrid/examples/common_grid.rs
index ac98933..b16ac69 100644
--- a/papergrid/examples/common_grid.rs
+++ b/papergrid/examples/common_grid.rs
@@ -36,7 +36,7 @@ fn main() {
     println!("{grid}");
 }
 
-fn generate_table_config() -> CompactConfig {
+const fn generate_table_config() -> CompactConfig {
     const STYLE: Borders<char> = Borders {
         top: Some('-'),
         top_left: Some('+'),
@@ -55,13 +55,15 @@ fn generate_table_config() -> CompactConfig {
         intersection: Some('+'),
     };
 
-    CompactConfig::default()
-        .set_borders(STYLE)
-        .set_alignment_horizontal(AlignmentHorizontal::Center)
-        .set_padding(Sides::new(
-            Indent::spaced(1),
-            Indent::spaced(1),
-            Indent::spaced(0),
-            Indent::spaced(0),
-        ))
+    let mut cfg = CompactConfig::new();
+    cfg.set_borders(STYLE);
+    cfg.set_alignment_horizontal(AlignmentHorizontal::Center);
+    cfg.set_padding(Sides::new(
+        Indent::spaced(1),
+        Indent::spaced(1),
+        Indent::spaced(0),
+        Indent::spaced(0),
+    ));
+
+    cfg
 }
diff --git a/papergrid/examples/common_grid_no_std.rs b/papergrid/examples/common_grid_no_std.rs
index ebb77bc..2abf1aa 100644
--- a/papergrid/examples/common_grid_no_std.rs
+++ b/papergrid/examples/common_grid_no_std.rs
@@ -30,7 +30,7 @@ fn main() {
     println!("{grid}");
 }
 
-fn generate_table_config() -> CompactConfig {
+const fn generate_table_config() -> CompactConfig {
     const STYLE: Borders<char> = Borders {
         top: Some('-'),
         top_left: Some('+'),
@@ -49,15 +49,17 @@ fn generate_table_config() -> CompactConfig {
         intersection: Some('+'),
     };
 
-    CompactConfig::default()
-        .set_borders(STYLE)
-        .set_alignment_horizontal(AlignmentHorizontal::Center)
-        .set_padding(Sides::new(
-            Indent::spaced(1),
-            Indent::spaced(1),
-            Indent::spaced(3),
-            Indent::spaced(0),
-        ))
+    let mut cfg = CompactConfig::new();
+    cfg.set_borders(STYLE);
+    cfg.set_alignment_horizontal(AlignmentHorizontal::Center);
+    cfg.set_padding(Sides::new(
+        Indent::spaced(1),
+        Indent::spaced(1),
+        Indent::spaced(3),
+        Indent::spaced(0),
+    ));
+
+    cfg
 }
 
 struct ConstDims<'a>(&'a [usize], usize);
diff --git a/papergrid/examples/hello_world.rs b/papergrid/examples/hello_world.rs
index 7f16e2c..3f61118 100644
--- a/papergrid/examples/hello_world.rs
+++ b/papergrid/examples/hello_world.rs
@@ -9,10 +9,11 @@
 
 use papergrid::{
     colors::NoColors,
-    config::spanned::SpannedConfig,
-    config::{AlignmentHorizontal, AlignmentVertical, Borders, Entity::Global, Indent, Sides},
-    dimension::spanned::SpannedGridDimension,
-    dimension::Estimate,
+    config::{
+        pos, spanned::SpannedConfig, AlignmentHorizontal, AlignmentVertical, Borders,
+        Entity::Global, Indent, Sides,
+    },
+    dimension::{spanned::SpannedGridDimension, Estimate},
     grid::iterable::Grid,
     records::IterRecords,
 };
@@ -60,8 +61,8 @@ fn generate_table_config() -> SpannedConfig {
 
     let mut cfg = SpannedConfig::default();
     cfg.set_borders(STYLE);
-    cfg.set_column_span((1, 1), 3);
-    cfg.set_row_span((0, 0), 2);
+    cfg.set_column_span(pos(1, 1), 3);
+    cfg.set_row_span(pos(0, 0), 2);
     cfg.set_alignment_horizontal((1, 0).into(), AlignmentHorizontal::Center);
     cfg.set_alignment_vertical(Global, AlignmentVertical::Center);
     cfg.set_padding(
diff --git a/papergrid/examples/span_usage.rs b/papergrid/examples/span_usage.rs
index f0a3180..38aa8ef 100644
--- a/papergrid/examples/span_usage.rs
+++ b/papergrid/examples/span_usage.rs
@@ -1,8 +1,8 @@
 use papergrid::{
     colors::NoColors,
     config::{
-        spanned::SpannedConfig, AlignmentHorizontal, AlignmentVertical, Borders, Entity, Indent,
-        Sides,
+        pos, spanned::SpannedConfig, AlignmentHorizontal, AlignmentVertical, Borders, Entity,
+        Indent, Sides,
     },
     dimension::{spanned::SpannedGridDimension, Estimate},
     grid::peekable::PeekableGrid,
@@ -28,8 +28,8 @@ fn main() {
         right: Some('|'),
         intersection: Some('+'),
     });
-    cfg.set_column_span((1, 1), 3);
-    cfg.set_row_span((0, 0), 2);
+    cfg.set_column_span(pos(1, 1), 3);
+    cfg.set_row_span(pos(0, 0), 2);
     cfg.set_alignment_horizontal((1, 0).into(), AlignmentHorizontal::Center);
     cfg.set_alignment_vertical(Entity::Global, AlignmentVertical::Center);
     cfg.set_padding(
diff --git a/papergrid/src/colors.rs b/papergrid/src/colors.rs
index e34b848..3cffda2 100644
--- a/papergrid/src/colors.rs
+++ b/papergrid/src/colors.rs
@@ -8,7 +8,7 @@ pub trait Colors {
     type Color: ANSIFmt;
 
     /// Returns a color for a given position.
-    fn get_color(&self, pos: (usize, usize)) -> Option<&Self::Color>;
+    fn get_color(&self, pos: Position) -> Option<&Self::Color>;
 
     /// Verifies whether a map is empty or not.
     fn is_empty(&self) -> bool;
diff --git a/papergrid/src/config/compact/mod.rs b/papergrid/src/config/compact/mod.rs
index 4ed8e9a..a6c61c9 100644
--- a/papergrid/src/config/compact/mod.rs
+++ b/papergrid/src/config/compact/mod.rs
@@ -45,9 +45,8 @@ impl CompactConfig {
     }
 
     /// Set grid margin.
-    pub const fn set_margin(mut self, margin: Sides<Indent>) -> Self {
+    pub const fn set_margin(&mut self, margin: Sides<Indent>) {
         self.margin = margin;
-        self
     }
 
     /// Returns a grid margin.
@@ -56,9 +55,8 @@ impl CompactConfig {
     }
 
     /// Set the [`Borders`] value as correct one.
-    pub const fn set_borders(mut self, borders: Borders<char>) -> Self {
+    pub const fn set_borders(&mut self, borders: Borders<char>) {
         self.borders = borders;
-        self
     }
 
     /// Returns a current [`Borders`] structure.
@@ -72,9 +70,8 @@ impl CompactConfig {
     }
 
     /// Set a padding to a given cells.
-    pub const fn set_padding(mut self, padding: Sides<Indent>) -> Self {
+    pub const fn set_padding(&mut self, padding: Sides<Indent>) {
         self.padding = padding;
-        self
     }
 
     /// Get a padding for a given.
@@ -83,9 +80,8 @@ impl CompactConfig {
     }
 
     /// Set a horizontal alignment.
-    pub const fn set_alignment_horizontal(mut self, alignment: AlignmentHorizontal) -> Self {
+    pub const fn set_alignment_horizontal(&mut self, alignment: AlignmentHorizontal) {
         self.halignment = alignment;
-        self
     }
 
     /// Get a alignment horizontal.
@@ -94,15 +90,13 @@ impl CompactConfig {
     }
 
     /// Sets colors of border carcass on the grid.
-    pub const fn set_borders_color(mut self, borders: Borders<ANSIStr<'static>>) -> Self {
+    pub const fn set_borders_color(&mut self, borders: Borders<ANSIStr<'static>>) {
         self.border_colors = borders;
-        self
     }
 
     /// Set colors for a margin.
-    pub const fn set_margin_color(mut self, color: Sides<ANSIStr<'static>>) -> Self {
+    pub const fn set_margin_color(&mut self, color: Sides<ANSIStr<'static>>) {
         self.margin_color = color;
-        self
     }
 
     /// Returns a margin color.
@@ -111,9 +105,8 @@ impl CompactConfig {
     }
 
     /// Set a padding to a given cells.
-    pub const fn set_padding_color(mut self, color: Sides<ANSIStr<'static>>) -> Self {
+    pub const fn set_padding_color(&mut self, color: Sides<ANSIStr<'static>>) {
         self.padding_color = color;
-        self
     }
 
     /// Set a padding to a given cells.
diff --git a/papergrid/src/config/entity.rs b/papergrid/src/config/entity.rs
index 40939bf..1d1daf7 100644
--- a/papergrid/src/config/entity.rs
+++ b/papergrid/src/config/entity.rs
@@ -42,8 +42,14 @@ impl Entity {
 }
 
 impl From<Position> for Entity {
-    fn from((row, col): Position) -> Self {
-        Self::Cell(row, col)
+    fn from(pos: Position) -> Self {
+        Self::Cell(pos.row(), pos.col())
+    }
+}
+
+impl From<(usize, usize)> for Entity {
+    fn from(pos: (usize, usize)) -> Self {
+        Self::Cell(pos.0, pos.1)
     }
 }
 
@@ -84,7 +90,7 @@ impl Iterator for EntityIterator {
                 self.count_cols = 0;
                 self.count_rows = 0;
 
-                Some((row, col))
+                Some(Position::new(row, col))
             }
             Entity::Column(col) => {
                 if self.i >= self.count_rows {
@@ -94,7 +100,7 @@ impl Iterator for EntityIterator {
                 let i = self.i;
                 self.i += 1;
 
-                Some((i, col))
+                Some(Position::new(i, col))
             }
             Entity::Row(row) => {
                 if self.j >= self.count_cols {
@@ -104,7 +110,7 @@ impl Iterator for EntityIterator {
                 let j = self.j;
                 self.j += 1;
 
-                Some((row, j))
+                Some(Position::new(row, j))
             }
             Entity::Global => {
                 if self.j >= self.count_cols {
@@ -119,7 +125,7 @@ impl Iterator for EntityIterator {
                 let j = self.j;
                 self.j += 1;
 
-                Some((self.i, j))
+                Some(Position::new(self.i, j))
             }
         }
     }
@@ -134,106 +140,106 @@ mod tests {
         assert_eq!(
             Entity::Global.iter(10, 10).collect::<Vec<_>>(),
             vec![
-                (0, 0),
-                (0, 1),
-                (0, 2),
-                (0, 3),
-                (0, 4),
-                (0, 5),
-                (0, 6),
-                (0, 7),
-                (0, 8),
-                (0, 9),
-                (1, 0),
-                (1, 1),
-                (1, 2),
-                (1, 3),
-                (1, 4),
-                (1, 5),
-                (1, 6),
-                (1, 7),
-                (1, 8),
-                (1, 9),
-                (2, 0),
-                (2, 1),
-                (2, 2),
-                (2, 3),
-                (2, 4),
-                (2, 5),
-                (2, 6),
-                (2, 7),
-                (2, 8),
-                (2, 9),
-                (3, 0),
-                (3, 1),
-                (3, 2),
-                (3, 3),
-                (3, 4),
-                (3, 5),
-                (3, 6),
-                (3, 7),
-                (3, 8),
-                (3, 9),
-                (4, 0),
-                (4, 1),
-                (4, 2),
-                (4, 3),
-                (4, 4),
-                (4, 5),
-                (4, 6),
-                (4, 7),
-                (4, 8),
-                (4, 9),
-                (5, 0),
-                (5, 1),
-                (5, 2),
-                (5, 3),
-                (5, 4),
-                (5, 5),
-                (5, 6),
-                (5, 7),
-                (5, 8),
-                (5, 9),
-                (6, 0),
-                (6, 1),
-                (6, 2),
-                (6, 3),
-                (6, 4),
-                (6, 5),
-                (6, 6),
-                (6, 7),
-                (6, 8),
-                (6, 9),
-                (7, 0),
-                (7, 1),
-                (7, 2),
-                (7, 3),
-                (7, 4),
-                (7, 5),
-                (7, 6),
-                (7, 7),
-                (7, 8),
-                (7, 9),
-                (8, 0),
-                (8, 1),
-                (8, 2),
-                (8, 3),
-                (8, 4),
-                (8, 5),
-                (8, 6),
-                (8, 7),
-                (8, 8),
-                (8, 9),
-                (9, 0),
-                (9, 1),
-                (9, 2),
-                (9, 3),
-                (9, 4),
-                (9, 5),
-                (9, 6),
-                (9, 7),
-                (9, 8),
-                (9, 9)
+                Position::new(0, 0),
+                Position::new(0, 1),
+                Position::new(0, 2),
+                Position::new(0, 3),
+                Position::new(0, 4),
+                Position::new(0, 5),
+                Position::new(0, 6),
+                Position::new(0, 7),
+                Position::new(0, 8),
+                Position::new(0, 9),
+                Position::new(1, 0),
+                Position::new(1, 1),
+                Position::new(1, 2),
+                Position::new(1, 3),
+                Position::new(1, 4),
+                Position::new(1, 5),
+                Position::new(1, 6),
+                Position::new(1, 7),
+                Position::new(1, 8),
+                Position::new(1, 9),
+                Position::new(2, 0),
+                Position::new(2, 1),
+                Position::new(2, 2),
+                Position::new(2, 3),
+                Position::new(2, 4),
+                Position::new(2, 5),
+                Position::new(2, 6),
+                Position::new(2, 7),
+                Position::new(2, 8),
+                Position::new(2, 9),
+                Position::new(3, 0),
+                Position::new(3, 1),
+                Position::new(3, 2),
+                Position::new(3, 3),
+                Position::new(3, 4),
+                Position::new(3, 5),
+                Position::new(3, 6),
+                Position::new(3, 7),
+                Position::new(3, 8),
+                Position::new(3, 9),
+                Position::new(4, 0),
+                Position::new(4, 1),
+                Position::new(4, 2),
+                Position::new(4, 3),
+                Position::new(4, 4),
+                Position::new(4, 5),
+                Position::new(4, 6),
+                Position::new(4, 7),
+                Position::new(4, 8),
+                Position::new(4, 9),
+                Position::new(5, 0),
+                Position::new(5, 1),
+                Position::new(5, 2),
+                Position::new(5, 3),
+                Position::new(5, 4),
+                Position::new(5, 5),
+                Position::new(5, 6),
+                Position::new(5, 7),
+                Position::new(5, 8),
+                Position::new(5, 9),
+                Position::new(6, 0),
+                Position::new(6, 1),
+                Position::new(6, 2),
+                Position::new(6, 3),
+                Position::new(6, 4),
+                Position::new(6, 5),
+                Position::new(6, 6),
+                Position::new(6, 7),
+                Position::new(6, 8),
+                Position::new(6, 9),
+                Position::new(7, 0),
+                Position::new(7, 1),
+                Position::new(7, 2),
+                Position::new(7, 3),
+                Position::new(7, 4),
+                Position::new(7, 5),
+                Position::new(7, 6),
+                Position::new(7, 7),
+                Position::new(7, 8),
+                Position::new(7, 9),
+                Position::new(8, 0),
+                Position::new(8, 1),
+                Position::new(8, 2),
+                Position::new(8, 3),
+                Position::new(8, 4),
+                Position::new(8, 5),
+                Position::new(8, 6),
+                Position::new(8, 7),
+                Position::new(8, 8),
+                Position::new(8, 9),
+                Position::new(9, 0),
+                Position::new(9, 1),
+                Position::new(9, 2),
+                Position::new(9, 3),
+                Position::new(9, 4),
+                Position::new(9, 5),
+                Position::new(9, 6),
+                Position::new(9, 7),
+                Position::new(9, 8),
+                Position::new(9, 9)
             ]
         );
     }
diff --git a/papergrid/src/config/indent.rs b/papergrid/src/config/indent.rs
index 4d98772..05240ce 100644
--- a/papergrid/src/config/indent.rs
+++ b/papergrid/src/config/indent.rs
@@ -22,6 +22,11 @@ impl Indent {
     pub const fn zero() -> Self {
         Self::new(0, ' ')
     }
+
+    /// Verifies whether an indent is set to 0.
+    pub const fn is_empty(&self) -> bool {
+        self.size == 0
+    }
 }
 
 impl Default for Indent {
diff --git a/papergrid/src/config/mod.rs b/papergrid/src/config/mod.rs
index a7180cb..e033775 100644
--- a/papergrid/src/config/mod.rs
+++ b/papergrid/src/config/mod.rs
@@ -22,6 +22,6 @@ pub use entity::{Entity, EntityIterator};
 pub use formatting::Formatting;
 pub use horizontal_line::HorizontalLine;
 pub use indent::Indent;
-pub use position::Position;
+pub use position::{pos, Position};
 pub use sides::Sides;
 pub use vertical_line::VerticalLine;
diff --git a/papergrid/src/config/position.rs b/papergrid/src/config/position.rs
index 3996453..51561ea 100644
--- a/papergrid/src/config/position.rs
+++ b/papergrid/src/config/position.rs
@@ -1,3 +1,11 @@
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+
+/// Constructs a [`Position`] in a convinient way.
+/// Basically a short hand for `(row, col).into()` or `Position::new(row, col)`.
+pub fn pos(row: usize, col: usize) -> Position {
+    Position::new(row, col)
+}
+
 /// Position is a (row, col) position on a Grid.
 ///
 /// For example such table has 4 cells.
@@ -10,4 +18,104 @@
 /// │ 1 │ 2 │
 /// └───┴───┘
 /// ```
-pub type Position = (usize, usize);
+#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Position {
+    row: usize,
+    col: usize,
+}
+
+impl Position {
+    /// Creates a new [`Position`] object.
+    pub const fn new(row: usize, col: usize) -> Self {
+        Self { row, col }
+    }
+
+    /// Returns a row value.
+    pub const fn row(&self) -> usize {
+        self.row
+    }
+
+    /// Returns a column value.
+    pub const fn col(&self) -> usize {
+        self.col
+    }
+
+    /// A check whether a cell is not beyond the maximum point.
+    /// Meaning it's less then a maximum point.
+    /// So it must be located left and bottom on XY axis.
+    pub const fn is_covered(&self, max: Position) -> bool {
+        self.row < max.row && self.col < max.col
+    }
+}
+
+impl Add<Position> for Position {
+    type Output = Position;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::new(self.row + rhs.row, self.col + rhs.col)
+    }
+}
+
+impl Add<(usize, usize)> for Position {
+    type Output = Position;
+
+    fn add(self, rhs: (usize, usize)) -> Self::Output {
+        Self::new(self.row + rhs.0, self.col + rhs.1)
+    }
+}
+
+impl Sub<Position> for Position {
+    type Output = Position;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self::new(self.row - rhs.row, self.col - rhs.col)
+    }
+}
+
+impl Sub<(usize, usize)> for Position {
+    type Output = Position;
+
+    fn sub(self, rhs: (usize, usize)) -> Self::Output {
+        Self::new(self.row - rhs.0, self.col - rhs.1)
+    }
+}
+
+impl AddAssign<Position> for Position {
+    fn add_assign(&mut self, rhs: Position) {
+        self.row += rhs.row;
+        self.col += rhs.col;
+    }
+}
+
+impl AddAssign<(usize, usize)> for Position {
+    fn add_assign(&mut self, rhs: (usize, usize)) {
+        self.row += rhs.0;
+        self.col += rhs.1;
+    }
+}
+
+impl SubAssign<Position> for Position {
+    fn sub_assign(&mut self, rhs: Position) {
+        self.row -= rhs.row;
+        self.col -= rhs.col;
+    }
+}
+
+impl SubAssign<(usize, usize)> for Position {
+    fn sub_assign(&mut self, rhs: (usize, usize)) {
+        self.row -= rhs.0;
+        self.col -= rhs.1;
+    }
+}
+
+impl From<(usize, usize)> for Position {
+    fn from(value: (usize, usize)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}
+
+impl From<Position> for (usize, usize) {
+    fn from(val: Position) -> Self {
+        (val.row(), val.col())
+    }
+}
diff --git a/papergrid/src/config/sides.rs b/papergrid/src/config/sides.rs
index 3185985..381df51 100644
--- a/papergrid/src/config/sides.rs
+++ b/papergrid/src/config/sides.rs
@@ -55,6 +55,22 @@ impl<T> Sides<T> {
             (f)(self.bottom),
         )
     }
+
+    /// Converts all sides with a given function.
+    pub fn fold<B, F>(self, acc: B, f: F) -> B
+    where
+        F: FnMut(B, T) -> B,
+    {
+        let mut f = f;
+        let mut acc = acc;
+
+        acc = (f)(acc, self.left);
+        acc = (f)(acc, self.right);
+        acc = (f)(acc, self.top);
+        acc = (f)(acc, self.bottom);
+
+        acc
+    }
 }
 
 impl<T> Sides<Option<T>> {
diff --git a/papergrid/src/config/spanned/borders_config.rs b/papergrid/src/config/spanned/borders_config.rs
index 003d79a..3597974 100644
--- a/papergrid/src/config/spanned/borders_config.rs
+++ b/papergrid/src/config/spanned/borders_config.rs
@@ -47,46 +47,46 @@ impl<T> BordersConfig<T> {
     pub(crate) fn insert_border(&mut self, pos: Position, border: Border<T>) {
         if let Some(c) = border.top {
             self.cells.horizontal.insert(pos, c);
-            self.layout.horizontals.insert(pos.0);
+            self.layout.horizontals.insert(pos.row());
         }
 
         if let Some(c) = border.bottom {
-            self.cells.horizontal.insert((pos.0 + 1, pos.1), c);
-            self.layout.horizontals.insert(pos.0 + 1);
+            self.cells.horizontal.insert(pos + (1, 0), c);
+            self.layout.horizontals.insert(pos.row() + 1);
         }
 
         if let Some(c) = border.left {
             self.cells.vertical.insert(pos, c);
-            self.layout.verticals.insert(pos.1);
+            self.layout.verticals.insert(pos.col());
         }
 
         if let Some(c) = border.right {
-            self.cells.vertical.insert((pos.0, pos.1 + 1), c);
-            self.layout.verticals.insert(pos.1 + 1);
+            self.cells.vertical.insert(pos + (0, 1), c);
+            self.layout.verticals.insert(pos.col() + 1);
         }
 
         if let Some(c) = border.left_top_corner {
-            self.cells.intersection.insert((pos.0, pos.1), c);
-            self.layout.horizontals.insert(pos.0);
-            self.layout.verticals.insert(pos.1);
+            self.cells.intersection.insert(pos, c);
+            self.layout.horizontals.insert(pos.row());
+            self.layout.verticals.insert(pos.col());
         }
 
         if let Some(c) = border.right_top_corner {
-            self.cells.intersection.insert((pos.0, pos.1 + 1), c);
-            self.layout.horizontals.insert(pos.0);
-            self.layout.verticals.insert(pos.1 + 1);
+            self.cells.intersection.insert(pos + (0, 1), c);
+            self.layout.horizontals.insert(pos.row());
+            self.layout.verticals.insert(pos.col() + 1);
         }
 
         if let Some(c) = border.left_bottom_corner {
-            self.cells.intersection.insert((pos.0 + 1, pos.1), c);
-            self.layout.horizontals.insert(pos.0 + 1);
-            self.layout.verticals.insert(pos.1);
+            self.cells.intersection.insert(pos + (1, 0), c);
+            self.layout.horizontals.insert(pos.row() + 1);
+            self.layout.verticals.insert(pos.col());
         }
 
         if let Some(c) = border.right_bottom_corner {
-            self.cells.intersection.insert((pos.0 + 1, pos.1 + 1), c);
-            self.layout.horizontals.insert(pos.0 + 1);
-            self.layout.verticals.insert(pos.1 + 1);
+            self.cells.intersection.insert(pos + (1, 1), c);
+            self.layout.horizontals.insert(pos.row() + 1);
+            self.layout.verticals.insert(pos.col() + 1);
         }
     }
 
@@ -94,43 +94,43 @@ impl<T> BordersConfig<T> {
         let (count_rows, count_cols) = shape;
 
         self.cells.horizontal.remove(&pos);
-        self.cells.horizontal.remove(&(pos.0 + 1, pos.1));
+        self.cells.horizontal.remove(&(pos + (1, 0)));
         self.cells.vertical.remove(&pos);
-        self.cells.vertical.remove(&(pos.0, pos.1 + 1));
+        self.cells.vertical.remove(&(pos + (0, 1)));
         self.cells.intersection.remove(&pos);
-        self.cells.intersection.remove(&(pos.0 + 1, pos.1));
-        self.cells.intersection.remove(&(pos.0, pos.1 + 1));
-        self.cells.intersection.remove(&(pos.0 + 1, pos.1 + 1));
+        self.cells.intersection.remove(&(pos + (1, 0)));
+        self.cells.intersection.remove(&(pos + (0, 1)));
+        self.cells.intersection.remove(&(pos + (1, 1)));
 
         // clean up the layout.
 
-        if !self.check_is_horizontal_set(pos.0, count_rows) {
-            self.layout.horizontals.remove(&pos.0);
+        if !self.check_is_horizontal_set(pos.row(), count_rows) {
+            self.layout.horizontals.remove(&pos.row());
         }
 
-        if !self.check_is_horizontal_set(pos.0 + 1, count_rows) {
-            self.layout.horizontals.remove(&(pos.0 + 1));
+        if !self.check_is_horizontal_set(pos.row() + 1, count_rows) {
+            self.layout.horizontals.remove(&(pos.row() + 1));
         }
 
-        if !self.check_is_vertical_set(pos.1, count_cols) {
-            self.layout.verticals.remove(&pos.1);
+        if !self.check_is_vertical_set(pos.col(), count_cols) {
+            self.layout.verticals.remove(&pos.col());
         }
 
-        if !self.check_is_vertical_set(pos.1 + 1, count_cols) {
-            self.layout.verticals.remove(&(pos.1 + 1));
+        if !self.check_is_vertical_set(pos.col() + 1, count_cols) {
+            self.layout.verticals.remove(&(pos.col() + 1));
         }
     }
 
     pub(crate) fn get_border(&self, pos: Position, shape: (usize, usize)) -> Border<&T> {
         Border {
             top: self.get_horizontal(pos, shape.0),
-            bottom: self.get_horizontal((pos.0 + 1, pos.1), shape.0),
+            bottom: self.get_horizontal(pos + (1, 0), shape.0),
             left: self.get_vertical(pos, shape.1),
             left_top_corner: self.get_intersection(pos, shape),
-            left_bottom_corner: self.get_intersection((pos.0 + 1, pos.1), shape),
-            right: self.get_vertical((pos.0, pos.1 + 1), shape.1),
-            right_top_corner: self.get_intersection((pos.0, pos.1 + 1), shape),
-            right_bottom_corner: self.get_intersection((pos.0 + 1, pos.1 + 1), shape),
+            left_bottom_corner: self.get_intersection(pos + (1, 0), shape),
+            right: self.get_vertical(pos + (0, 1), shape.1),
+            right_top_corner: self.get_intersection(pos + (0, 1), shape),
+            right_bottom_corner: self.get_intersection(pos + (1, 1), shape),
         }
     }
 
@@ -222,11 +222,11 @@ impl<T> BordersConfig<T> {
         self.cells
             .vertical
             .get(&pos)
-            .or_else(|| self.verticals.get(&pos.1).and_then(|l| l.main.as_ref()))
+            .or_else(|| self.verticals.get(&pos.col()).and_then(|l| l.main.as_ref()))
             .or({
-                if pos.1 == count_cols {
+                if pos.col() == count_cols {
                     self.borders.right.as_ref()
-                } else if pos.1 == 0 {
+                } else if pos.col() == 0 {
                     self.borders.left.as_ref()
                 } else {
                     self.borders.vertical.as_ref()
@@ -239,11 +239,15 @@ impl<T> BordersConfig<T> {
         self.cells
             .horizontal
             .get(&pos)
-            .or_else(|| self.horizontals.get(&pos.0).and_then(|l| l.main.as_ref()))
+            .or_else(|| {
+                self.horizontals
+                    .get(&pos.row())
+                    .and_then(|l| l.main.as_ref())
+            })
             .or({
-                if pos.0 == 0 {
+                if pos.row() == 0 {
                     self.borders.top.as_ref()
-                } else if pos.0 == count_rows {
+                } else if pos.row() == count_rows {
                     self.borders.bottom.as_ref()
                 } else {
                     self.borders.horizontal.as_ref()
@@ -257,17 +261,17 @@ impl<T> BordersConfig<T> {
         pos: Position,
         (count_rows, count_cols): (usize, usize),
     ) -> Option<&T> {
-        let use_top = pos.0 == 0;
-        let use_bottom = pos.0 == count_rows;
-        let use_left = pos.1 == 0;
-        let use_right = pos.1 == count_cols;
+        let use_top = pos.row() == 0;
+        let use_bottom = pos.row() == count_rows;
+        let use_left = pos.col() == 0;
+        let use_right = pos.col() == count_cols;
 
         let intersection = self.cells.intersection.get(&pos);
         if intersection.is_some() {
             return intersection;
         }
 
-        let intersection = self.horizontals.get(&pos.0).and_then(|l| {
+        let intersection = self.horizontals.get(&pos.row()).and_then(|l| {
             if use_left && l.left.is_some() {
                 l.left.as_ref()
             } else if use_right && l.right.is_some() {
@@ -282,7 +286,7 @@ impl<T> BordersConfig<T> {
             return intersection;
         }
 
-        let intersection = self.verticals.get(&pos.1).and_then(|l| {
+        let intersection = self.verticals.get(&pos.col()).and_then(|l| {
             if use_top && l.top.is_some() {
                 l.top.as_ref()
             } else if use_bottom && l.bottom.is_some() {
@@ -356,15 +360,15 @@ impl<T> BordersConfig<T> {
     fn check_is_horizontal_set(&self, row: usize, count_rows: usize) -> bool {
         (row == 0 && self.layout.top)
             || (row == count_rows && self.layout.bottom)
-            || self.cells.horizontal.keys().any(|&p| p.0 == row)
-            || self.cells.intersection.keys().any(|&p| p.0 == row)
+            || self.cells.horizontal.keys().any(|&p| p.row() == row)
+            || self.cells.intersection.keys().any(|&p| p.row() == row)
     }
 
     fn check_is_vertical_set(&self, col: usize, count_cols: usize) -> bool {
         (col == 0 && self.layout.left)
             || (col == count_cols && self.layout.right)
-            || self.cells.vertical.keys().any(|&p| p.1 == col)
-            || self.cells.intersection.keys().any(|&p| p.1 == col)
+            || self.cells.vertical.keys().any(|&p| p.col() == col)
+            || self.cells.intersection.keys().any(|&p| p.col() == col)
     }
 }
 
@@ -375,10 +379,16 @@ mod tests {
     #[test]
     fn test_insert_border() {
         let mut borders = BordersConfig::<char>::default();
-        borders.insert_border((0, 0), Border::filled('x'));
+        borders.insert_border((0, 0).into(), Border::filled('x'));
 
-        assert_eq!(borders.get_border((0, 0), (10, 10)), Border::filled(&'x'));
-        assert_eq!(borders.get_border((0, 0), (0, 0)), Border::filled(&'x'));
+        assert_eq!(
+            borders.get_border((0, 0).into(), (10, 10)),
+            Border::filled(&'x')
+        );
+        assert_eq!(
+            borders.get_border((0, 0).into(), (0, 0)),
+            Border::filled(&'x')
+        );
 
         assert!(borders.is_horizontal_set(0, 10));
         assert!(borders.is_horizontal_set(1, 10));
@@ -398,25 +408,25 @@ mod tests {
     #[test]
     fn test_insert_border_override() {
         let mut borders = BordersConfig::<char>::default();
-        borders.insert_border((0, 0), Border::filled('x'));
-        borders.insert_border((1, 0), Border::filled('y'));
-        borders.insert_border((0, 1), Border::filled('w'));
-        borders.insert_border((1, 1), Border::filled('q'));
+        borders.insert_border((0, 0).into(), Border::filled('x'));
+        borders.insert_border((1, 0).into(), Border::filled('y'));
+        borders.insert_border((0, 1).into(), Border::filled('w'));
+        borders.insert_border((1, 1).into(), Border::filled('q'));
 
         assert_eq!(
-            borders.get_border((0, 0), (10, 10)).copied(),
+            borders.get_border((0, 0).into(), (10, 10)).copied(),
             Border::full('x', 'y', 'x', 'w', 'x', 'w', 'y', 'q')
         );
         assert_eq!(
-            borders.get_border((0, 1), (10, 10)).copied(),
+            borders.get_border((0, 1).into(), (10, 10)).copied(),
             Border::full('w', 'q', 'w', 'w', 'w', 'w', 'q', 'q')
         );
         assert_eq!(
-            borders.get_border((1, 0), (10, 10)).copied(),
+            borders.get_border((1, 0).into(), (10, 10)).copied(),
             Border::full('y', 'y', 'y', 'q', 'y', 'q', 'y', 'q')
         );
         assert_eq!(
-            borders.get_border((1, 1), (10, 10)).copied(),
+            borders.get_border((1, 1).into(), (10, 10)).copied(),
             Border::filled('q')
         );
 
@@ -433,11 +443,17 @@ mod tests {
     #[test]
     fn test_set_global() {
         let mut borders = BordersConfig::<char>::default();
-        borders.insert_border((0, 0), Border::filled('x'));
+        borders.insert_border((0, 0).into(), Border::filled('x'));
         borders.set_global('l');
 
-        assert_eq!(borders.get_border((0, 0), (10, 10)), Border::filled(&'x'));
-        assert_eq!(borders.get_border((2, 0), (10, 10)), Border::filled(&'l'));
+        assert_eq!(
+            borders.get_border((0, 0).into(), (10, 10)),
+            Border::filled(&'x')
+        );
+        assert_eq!(
+            borders.get_border((2, 0).into(), (10, 10)),
+            Border::filled(&'l')
+        );
 
         assert!(borders.is_horizontal_set(0, 10));
         assert!(borders.is_horizontal_set(1, 10));
diff --git a/papergrid/src/config/spanned/entity_map.rs b/papergrid/src/config/spanned/entity_map.rs
index 79f072c..6ea2a90 100644
--- a/papergrid/src/config/spanned/entity_map.rs
+++ b/papergrid/src/config/spanned/entity_map.rs
@@ -32,7 +32,7 @@ impl<T> EntityMap<T> {
     }
 
     /// Get a value for an [`Entity`].
-    pub fn get(&self, (row, col): Position) -> &T {
+    pub fn get(&self, pos: Position) -> &T {
         // todo: optimize;
         //
         // Cause we can change rows/columns/cells separately we need to check them separately.
@@ -51,9 +51,9 @@ impl<T> EntityMap<T> {
         // ref: https://users.rust-lang.org/t/make-hash-return-same-value-whather-the-order-of-element-of-a-tuple/69932/13
 
         self.cells
-            .get(&(row, col))
-            .or_else(|| self.columns.get(&col))
-            .or_else(|| self.rows.get(&row))
+            .get(&pos)
+            .or_else(|| self.columns.get(&pos.col()))
+            .or_else(|| self.rows.get(&pos.row()))
             .unwrap_or(&self.global)
     }
 
@@ -65,10 +65,10 @@ impl<T> EntityMap<T> {
                 self.rows.clear();
                 self.columns.clear();
             }
-            Entity::Column(col) => self.cells.retain(|&(_, c), _| c != col),
-            Entity::Row(row) => self.cells.retain(|&(r, _), _| r != row),
+            Entity::Column(col) => self.cells.retain(|pos, _| pos.col() != col),
+            Entity::Row(row) => self.cells.retain(|pos, _| pos.row() != row),
             Entity::Cell(row, col) => {
-                self.cells.remove(&(row, col));
+                self.cells.remove(&Position::new(row, col));
             }
         }
     }
@@ -80,20 +80,20 @@ impl<T: Clone> EntityMap<T> {
         match entity {
             Entity::Column(col) => {
                 for &row in self.rows.keys() {
-                    self.cells.insert((row, col), value.clone());
+                    self.cells.insert(Position::new(row, col), value.clone());
                 }
 
                 self.columns.insert(col, value);
             }
             Entity::Row(row) => {
                 for &col in self.columns.keys() {
-                    self.cells.insert((row, col), value.clone());
+                    self.cells.insert(Position::new(row, col), value.clone());
                 }
 
                 self.rows.insert(row, value);
             }
             Entity::Cell(row, col) => {
-                self.cells.insert((row, col), value);
+                self.cells.insert(Position::new(row, col), value);
             }
             Entity::Global => {
                 self.remove(Entity::Global);
@@ -108,8 +108,8 @@ impl<T> From<EntityMap<T>> for HashMap<Entity, T> {
         let mut m = HashMap::new();
         m.insert(Entity::Global, value.global);
 
-        for ((row, col), value) in value.cells {
-            m.insert(Entity::Cell(row, col), value);
+        for (pos, value) in value.cells {
+            m.insert(Entity::from(pos), value);
         }
 
         for (row, value) in value.rows {
diff --git a/papergrid/src/config/spanned/mod.rs b/papergrid/src/config/spanned/mod.rs
index a41046b..47c2a17 100644
--- a/papergrid/src/config/spanned/mod.rs
+++ b/papergrid/src/config/spanned/mod.rs
@@ -716,7 +716,7 @@ impl SpannedConfig {
             return Some(*c);
         }
 
-        if self.has_horizontal(pos.0, shape.0) && self.has_vertical(pos.1, shape.1) {
+        if self.has_horizontal(pos.row(), shape.0) && self.has_vertical(pos.col(), shape.1) {
             return Some(self.get_borders_missing());
         }
 
@@ -732,7 +732,7 @@ impl SpannedConfig {
             return Some(*c);
         }
 
-        if self.has_horizontal(pos.0, count_rows) {
+        if self.has_horizontal(pos.row(), count_rows) {
             return Some(self.get_borders_missing());
         }
 
@@ -747,7 +747,7 @@ impl SpannedConfig {
             return Some(*c);
         }
 
-        if self.has_vertical(pos.1, count_columns) {
+        if self.has_vertical(pos.col(), count_columns) {
             return Some(self.get_borders_missing());
         }
 
@@ -886,13 +886,13 @@ fn set_cell_column_span(cfg: &mut SpannedConfig, pos: Position, span: usize) {
 fn is_cell_covered_by_column_span(cfg: &SpannedConfig, pos: Position) -> bool {
     cfg.span_columns
         .iter()
-        .any(|(&(row, col), span)| pos.1 > col && pos.1 < col + span && row == pos.0)
+        .any(|(p, span)| p.row() == pos.row() && pos.col() > p.col() && pos.col() < p.col() + span)
 }
 
 fn is_cell_covered_by_row_span(cfg: &SpannedConfig, pos: Position) -> bool {
     cfg.span_rows
         .iter()
-        .any(|(&(row, col), span)| pos.0 > row && pos.0 < row + span && col == pos.1)
+        .any(|(p, span)| p.col() == pos.col() && pos.row() > p.row() && pos.row() < p.row() + span)
 }
 
 fn is_cell_covered_by_both_spans(cfg: &SpannedConfig, pos: Position) -> bool {
@@ -905,7 +905,10 @@ fn is_cell_covered_by_both_spans(cfg: &SpannedConfig, pos: Position) -> bool {
             .iter()
             .filter(|(p2, _)| &p1 == p2)
             .any(|(_, col_span)| {
-                pos.0 > p1.0 && pos.0 < p1.0 + row_span && pos.1 > p1.1 && pos.1 < p1.1 + col_span
+                pos.row() > p1.row()
+                    && pos.row() < p1.row() + row_span
+                    && pos.col() > p1.col()
+                    && pos.col() < p1.col() + col_span
             })
     })
 }
diff --git a/papergrid/src/dimension/spanned.rs b/papergrid/src/dimension/spanned.rs
index 7d52669..f102315 100644
--- a/papergrid/src/dimension/spanned.rs
+++ b/papergrid/src/dimension/spanned.rs
@@ -106,7 +106,7 @@ where
     for (row, columns) in records.iter_rows().into_iter().enumerate() {
         let mut row_height = 0;
         for (col, cell) in columns.into_iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
@@ -153,17 +153,14 @@ fn adjust_hspans(
         return;
     }
 
-    let mut spans_ordered = spans
-        .iter()
-        .map(|(k, v)| ((k.0, k.1), *v))
-        .collect::<Vec<_>>();
+    let mut spans_ordered = spans.iter().map(|(k, v)| (k, *v)).collect::<Vec<_>>();
     spans_ordered.sort_unstable_by(|(arow, acol), (brow, bcol)| match arow.cmp(brow) {
         Ordering::Equal => acol.cmp(bcol),
         ord => ord,
     });
 
-    for ((row, _), (span, height)) in spans_ordered {
-        adjust_row_range(cfg, height, len, row, row + span, heights);
+    for (pos, (span, height)) in spans_ordered {
+        adjust_row_range(cfg, height, len, pos.row(), pos.row() + span, heights);
     }
 }
 
@@ -242,17 +239,14 @@ fn adjust_vspans(
     // The overall width distribution will be different depend on the order.
     //
     // We sort spans in order to prioritize the smaller spans first.
-    let mut spans_ordered = spans
-        .iter()
-        .map(|(k, v)| ((k.0, k.1), *v))
-        .collect::<Vec<_>>();
+    let mut spans_ordered = spans.iter().map(|(k, v)| (k, *v)).collect::<Vec<_>>();
     spans_ordered.sort_unstable_by(|a, b| match a.1 .0.cmp(&b.1 .0) {
-        Ordering::Equal => a.0.cmp(&b.0),
+        Ordering::Equal => a.0.cmp(b.0),
         o => o,
     });
 
-    for ((_, col), (span, width)) in spans_ordered {
-        adjust_column_range(cfg, width, len, col, col + span, widths);
+    for (pos, (span, width)) in spans_ordered {
+        adjust_column_range(cfg, width, len, pos.col(), pos.col() + span, widths);
     }
 }
 
@@ -313,7 +307,7 @@ where
     for (row, columns) in records.iter_rows().into_iter().enumerate() {
         let mut row_height = 0;
         for (col, cell) in columns.into_iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
@@ -347,7 +341,7 @@ where
 
     for (row, columns) in records.iter_rows().into_iter().enumerate() {
         for (col, cell) in columns.into_iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
diff --git a/papergrid/src/dimension/spanned_vec_records.rs b/papergrid/src/dimension/spanned_vec_records.rs
index 88aefb0..bfa88f8 100644
--- a/papergrid/src/dimension/spanned_vec_records.rs
+++ b/papergrid/src/dimension/spanned_vec_records.rs
@@ -85,7 +85,7 @@ fn build_dimensions<T: Cell + AsRef<str>>(
     for (row, columns) in records.iter_rows().enumerate() {
         let mut row_height = 0;
         for (col, cell) in columns.iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
@@ -132,17 +132,14 @@ fn adjust_hspans(
         return;
     }
 
-    let mut spans_ordered = spans
-        .iter()
-        .map(|(k, v)| ((k.0, k.1), *v))
-        .collect::<Vec<_>>();
+    let mut spans_ordered = spans.iter().map(|(k, v)| (*k, *v)).collect::<Vec<_>>();
     spans_ordered.sort_unstable_by(|(arow, acol), (brow, bcol)| match arow.cmp(brow) {
         Ordering::Equal => acol.cmp(bcol),
         ord => ord,
     });
 
-    for ((row, _), (span, height)) in spans_ordered {
-        adjust_row_range(cfg, height, len, row, row + span, heights);
+    for (pos, (span, height)) in spans_ordered {
+        adjust_row_range(cfg, height, len, pos.row(), pos.row() + span, heights);
     }
 }
 
@@ -215,17 +212,14 @@ fn adjust_vspans(
     // The overall width distribution will be different depend on the order.
     //
     // We sort spans in order to prioritize the smaller spans first.
-    let mut spans_ordered = spans
-        .iter()
-        .map(|(k, v)| ((k.0, k.1), *v))
-        .collect::<Vec<_>>();
+    let mut spans_ordered = spans.iter().map(|(k, v)| (*k, *v)).collect::<Vec<_>>();
     spans_ordered.sort_unstable_by(|a, b| match a.1 .0.cmp(&b.1 .0) {
         Ordering::Equal => a.0.cmp(&b.0),
         o => o,
     });
 
-    for ((_, col), (span, width)) in spans_ordered {
-        adjust_column_range(cfg, width, len, col, col + span, widths);
+    for (pos, (span, width)) in spans_ordered {
+        adjust_column_range(cfg, width, len, pos.col(), pos.col() + span, widths);
     }
 }
 
@@ -281,7 +275,7 @@ fn build_height<T: Cell + AsRef<str>>(records: &VecRecords<T>, cfg: &SpannedConf
     for (row, columns) in records.iter_rows().enumerate() {
         let mut row_height = 0;
         for (col, cell) in columns.iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
@@ -303,7 +297,10 @@ fn build_height<T: Cell + AsRef<str>>(records: &VecRecords<T>, cfg: &SpannedConf
     heights
 }
 
-fn build_width<T: Cell + AsRef<str>>(records: &VecRecords<T>, cfg: &SpannedConfig) -> Vec<usize> {
+fn build_width<T>(records: &VecRecords<T>, cfg: &SpannedConfig) -> Vec<usize>
+where
+    T: Cell + AsRef<str>,
+{
     let count_columns = records.count_columns();
 
     let mut widths = vec![0; count_columns];
@@ -311,12 +308,12 @@ fn build_width<T: Cell + AsRef<str>>(records: &VecRecords<T>, cfg: &SpannedConfi
 
     for (row, columns) in records.iter_rows().enumerate() {
         for (col, cell) in columns.iter().enumerate() {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if !cfg.is_cell_visible(pos) {
                 continue;
             }
 
-            let width = cell.width() + get_cell_padding_horizontal(cfg, (row, col));
+            let width = cell.width() + get_cell_padding_horizontal(cfg, pos);
             match cfg.get_column_span(pos) {
                 Some(n) if n > 1 => {
                     vspans.insert(pos, (n, width));
diff --git a/papergrid/src/grid/compact.rs b/papergrid/src/grid/compact.rs
index 9f1814e..22b6123 100644
--- a/papergrid/src/grid/compact.rs
+++ b/papergrid/src/grid/compact.rs
@@ -466,7 +466,7 @@ where
         .next()
         .expect("we check in the beginning that size must be at least 1 column");
     let width = dims.get_width(0);
-    let color = colors.get_color((row, 0));
+    let color = colors.get_color((row, 0).into());
 
     let text = text.as_ref();
     let text = text.lines().next().unwrap_or("");
@@ -478,7 +478,7 @@ where
                 let col = col + 1;
 
                 let width = dims.get_width(col);
-                let color = colors.get_color((row, col));
+                let color = colors.get_color((row, col).into());
                 let text = text.as_ref();
                 let text = text.lines().next().unwrap_or("");
 
@@ -491,7 +491,7 @@ where
                 let col = col + 1;
 
                 let width = dims.get_width(col);
-                let color = colors.get_color((row, col));
+                let color = colors.get_color((row, col).into());
                 let text = text.as_ref();
                 let text = text.lines().next().unwrap_or("");
 
diff --git a/papergrid/src/grid/iterable.rs b/papergrid/src/grid/iterable.rs
index c32fd26..e503eed 100644
--- a/papergrid/src/grid/iterable.rs
+++ b/papergrid/src/grid/iterable.rs
@@ -272,14 +272,14 @@ where
     print_margin_left(f, cfg, line, totalh)?;
 
     for (col, cell) in columns.enumerate() {
-        let pos = (row, col);
+        let pos = (row, col).into();
         let width = dims.get_width(col);
         let color = colors.get_color(pos);
         print_vertical_char(f, cfg, pos, 0, 1, shape.1)?;
         print_single_line_column(f, cell.as_ref(), cfg, width, color, pos)?;
     }
 
-    print_vertical_char(f, cfg, (row, shape.1), 0, 1, shape.1)?;
+    print_vertical_char(f, cfg, (row, shape.1).into(), 0, 1, shape.1)?;
 
     print_margin_right(f, cfg, line, totalh)?;
 
@@ -344,11 +344,11 @@ fn print_columns_lines<T, F: Write, C: ANSIFmt>(
         print_margin_left(f, cfg, exact_line, totalh)?;
 
         for (col, cell) in buf.iter_mut().enumerate() {
-            print_vertical_char(f, cfg, (row, col), i, height, shape.1)?;
+            print_vertical_char(f, cfg, (row, col).into(), i, height, shape.1)?;
             cell.display(f)?;
         }
 
-        print_vertical_char(f, cfg, (row, shape.1), i, height, shape.1)?;
+        print_vertical_char(f, cfg, (row, shape.1).into(), i, height, shape.1)?;
 
         print_margin_right(f, cfg, exact_line, totalh)?;
 
@@ -375,7 +375,7 @@ fn collect_columns<'a, I, D, C>(
     D: Dimension,
 {
     let iter = iter.enumerate().map(|(col, cell)| {
-        let pos = (row, col);
+        let pos = (row, col).into();
         let width = dimension.get_width(col);
         let color = colors.get_color(pos);
         Cell::new(cell, width, height, cfg, color, pos)
@@ -392,14 +392,14 @@ fn print_split_line<F: Write, D: Dimension>(
     shape: (usize, usize),
 ) -> fmt::Result {
     let mut used_color = None;
-    print_vertical_intersection(f, cfg, (row, 0), shape, &mut used_color)?;
+    print_vertical_intersection(f, cfg, (row, 0).into(), shape, &mut used_color)?;
 
     for col in 0..shape.1 {
         let width = dimension.get_width(col);
 
         // general case
         if width > 0 {
-            let pos = (row, col);
+            let pos = (row, col).into();
             let main = cfg.get_horizontal(pos, shape.0);
             match main {
                 Some(c) => {
@@ -411,7 +411,7 @@ fn print_split_line<F: Write, D: Dimension>(
             }
         }
 
-        print_vertical_intersection(f, cfg, (row, col + 1), shape, &mut used_color)?;
+        print_vertical_intersection(f, cfg, (row, col + 1).into(), shape, &mut used_color)?;
     }
 
     if let Some(clr) = used_color.take() {
@@ -522,10 +522,10 @@ fn print_split_line_spanned<S, F: Write, D: Dimension, C: ANSIFmt>(
     shape: (usize, usize),
 ) -> fmt::Result {
     let mut used_color = None;
-    print_vertical_intersection(f, cfg, (row, 0), shape, &mut used_color)?;
+    print_vertical_intersection(f, cfg, (row, 0).into(), shape, &mut used_color)?;
 
     for col in 0..shape.1 {
-        let pos = (row, col);
+        let pos = (row, col).into();
         if cfg.is_cell_covered_by_both_spans(pos) {
             continue;
         }
@@ -541,7 +541,7 @@ fn print_split_line_spanned<S, F: Write, D: Dimension, C: ANSIFmt>(
 
             // We need to use a correct right split char.
             let original_row = closest_visible_row(cfg, pos).unwrap();
-            if let Some(span) = cfg.get_column_span((original_row, col)) {
+            if let Some(span) = cfg.get_column_span((original_row, col).into()) {
                 col += span - 1;
             }
         } else if width > 0 {
@@ -557,7 +557,7 @@ fn print_split_line_spanned<S, F: Write, D: Dimension, C: ANSIFmt>(
             }
         }
 
-        print_vertical_intersection(f, cfg, (row, col + 1), shape, &mut used_color)?;
+        print_vertical_intersection(f, cfg, (row, col + 1).into(), shape, &mut used_color)?;
     }
 
     if let Some(clr) = used_color.take() {
@@ -574,7 +574,7 @@ fn print_vertical_intersection<'a, F: fmt::Write>(
     shape: (usize, usize),
     used_color: &mut Option<&'a ANSIBuf>,
 ) -> fmt::Result {
-    if !cfg.has_vertical(pos.1, shape.1) {
+    if !cfg.has_vertical(pos.col(), shape.1) {
         return Ok(());
     }
 
@@ -625,7 +625,7 @@ where
                 continue;
             }
 
-            let pos = (row, col);
+            let pos = (row, col).into();
             let rowspan = cfg.get_row_span(pos).unwrap_or(1);
             if rowspan < 2 {
                 continue;
@@ -671,7 +671,7 @@ where
             continue;
         }
 
-        let pos = (row, col);
+        let pos = (row, col).into();
         let colspan = cfg.get_column_span(pos).unwrap_or(1);
         skip = colspan - 1;
 
@@ -701,11 +701,18 @@ where
         print_margin_left(f, cfg, exact_line, totalh)?;
 
         for (&col, (cell, _, _)) in buf.iter_mut() {
-            print_vertical_char(f, cfg, (row, col), cell_line, this_height, shape.1)?;
+            print_vertical_char(f, cfg, (row, col).into(), cell_line, this_height, shape.1)?;
             cell.display(f)?;
         }
 
-        print_vertical_char(f, cfg, (row, shape.1), cell_line, this_height, shape.1)?;
+        print_vertical_char(
+            f,
+            cfg,
+            (row, shape.1).into(),
+            cell_line,
+            this_height,
+            shape.1,
+        )?;
 
         print_margin_right(f, cfg, exact_line, totalh)?;
 
@@ -1225,14 +1232,14 @@ fn count_verticals_in_range(cfg: &SpannedConfig, start: usize, end: usize, max:
 fn closest_visible_row(cfg: &SpannedConfig, mut pos: Position) -> Option<usize> {
     loop {
         if cfg.is_cell_visible(pos) {
-            return Some(pos.0);
+            return Some(pos.row());
         }
 
-        if pos.0 == 0 {
+        if pos.row() == 0 {
             return None;
         }
 
-        pos.0 -= 1;
+        pos -= (1, 0);
     }
 }
 
diff --git a/papergrid/src/grid/peekable.rs b/papergrid/src/grid/peekable.rs
index deddac6..c394234 100644
--- a/papergrid/src/grid/peekable.rs
+++ b/papergrid/src/grid/peekable.rs
@@ -209,12 +209,12 @@ mod grid_basic {
         D: Dimension,
     {
         for col in 0..shape.count_columns {
-            let pos = (row, col);
+            let pos = (row, col).into();
             print_vertical_char(f, ctx.cfg, pos, shape.count_columns)?;
             print_cell_line(f, ctx, height, pos, line)?;
         }
 
-        let pos = (row, shape.count_columns);
+        let pos = (row, shape.count_columns).into();
         print_vertical_char(f, ctx.cfg, pos, shape.count_columns)?;
 
         Ok(())
@@ -231,14 +231,14 @@ mod grid_basic {
         F: Write,
         D: Dimension,
     {
-        print_vertical_intersection(f, cfg, (row, 0), shape)?;
+        print_vertical_intersection(f, cfg, (row, 0).into(), shape)?;
 
         for col in 0..shape.count_columns {
             let width = dimension.get_width(col);
 
             // general case
             if width > 0 {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 let main = cfg.get_horizontal(pos, shape.count_rows);
                 match main {
                     Some(c) => repeat_char(f, c, width)?,
@@ -246,7 +246,7 @@ mod grid_basic {
                 }
             }
 
-            let pos = (row, col + 1);
+            let pos = (row, col + 1).into();
             print_vertical_intersection(f, cfg, pos, shape)?;
         }
 
@@ -273,7 +273,7 @@ mod grid_basic {
         //
         // todo: Yes... this check very likely degrages performance a bit,
         //       Surely we need to rethink it.
-        if !cfg.has_vertical(pos.1, shape.count_columns) {
+        if !cfg.has_vertical(pos.col(), shape.count_columns) {
             return Ok(());
         }
 
@@ -313,7 +313,7 @@ mod grid_basic {
         R: Records + PeekableRecords + ExactRecords,
         D: Dimension,
     {
-        let width = ctx.dims.get_width(pos.1);
+        let width = ctx.dims.get_width(pos.col());
 
         let pad = ctx.cfg.get_padding(pos);
         let valignment = *ctx.cfg.get_alignment_vertical(pos);
@@ -591,12 +591,13 @@ mod grid_not_spanned {
                 print_margin_left(f, ctx.cfg, table_line, total_height)?;
 
                 for col in 0..shape.count_columns {
-                    print_vertical_char(f, ctx.cfg, (row, col), i, height, shape.count_columns)?;
-                    print_cell_line(f, &ctx, height, (row, col), i)?;
+                    let pos = (row, col).into();
+                    print_vertical_char(f, ctx.cfg, pos, i, height, shape.count_columns)?;
+                    print_cell_line(f, &ctx, height, pos, i)?;
 
                     let is_last_column = col + 1 == shape.count_columns;
                     if is_last_column {
-                        let pos = (row, col + 1);
+                        let pos = (row, col + 1).into();
                         print_vertical_char(f, ctx.cfg, pos, i, height, shape.count_columns)?;
                     }
                 }
@@ -640,14 +641,14 @@ mod grid_not_spanned {
         D: Dimension,
     {
         let mut used_color = None;
-        print_vertical_intersection(f, cfg, (row, 0), shape, &mut used_color)?;
+        print_vertical_intersection(f, cfg, (row, 0).into(), shape, &mut used_color)?;
 
         for col in 0..shape.count_columns {
             let width = dimension.get_width(col);
 
             // general case
             if width > 0 {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 let main = cfg.get_horizontal(pos, shape.count_rows);
                 match main {
                     Some(c) => {
@@ -659,7 +660,7 @@ mod grid_not_spanned {
                 }
             }
 
-            let pos = (row, col + 1);
+            let pos = (row, col + 1).into();
             print_vertical_intersection(f, cfg, pos, shape, &mut used_color)?;
         }
 
@@ -691,7 +692,7 @@ mod grid_not_spanned {
         //
         // todo: Yes... this check very likely degrages performance a bit,
         //       Surely we need to rethink it.
-        if !cfg.has_vertical(pos.1, shape.count_columns) {
+        if !cfg.has_vertical(pos.col(), shape.count_columns) {
             return Ok(());
         }
 
@@ -822,7 +823,7 @@ mod grid_not_spanned {
         C: Colors,
         D: Dimension,
     {
-        let width = ctx.dims.get_width(pos.1);
+        let width = ctx.dims.get_width(pos.col());
 
         let formatting = ctx.cfg.get_formatting(pos);
         let text_cfg = TextCfg {
@@ -1327,7 +1328,7 @@ mod grid_spanned {
                 print_margin_left(f, ctx.cfg, table_line, total_height)?;
 
                 for col in 0..shape.count_columns {
-                    let pos = (row, col);
+                    let pos = (row, col).into();
 
                     if ctx.cfg.is_cell_covered_by_both_spans(pos) {
                         continue;
@@ -1336,7 +1337,7 @@ mod grid_spanned {
                     if ctx.cfg.is_cell_covered_by_column_span(pos) {
                         let is_last_column = col + 1 == shape.count_columns;
                         if is_last_column {
-                            let pos = (row, col + 1);
+                            let pos = (row, col + 1).into();
                             let count_columns = shape.count_columns;
                             print_vertical_char(f, ctx.cfg, pos, i, count_lines, count_columns)?;
                         }
@@ -1361,7 +1362,7 @@ mod grid_spanned {
                             .sum::<usize>();
 
                         let line = i + skip_lines;
-                        let pos = (original_row, col);
+                        let pos = (original_row, col).into();
 
                         let width = get_cell_width(ctx.cfg, ctx.dims, pos, shape.count_columns);
                         let height = get_cell_height(ctx.cfg, ctx.dims, pos, shape.count_rows);
@@ -1375,7 +1376,7 @@ mod grid_spanned {
 
                     let is_last_column = col + 1 == shape.count_columns;
                     if is_last_column {
-                        let pos = (row, col + 1);
+                        let pos = (row, col + 1).into();
                         print_vertical_char(f, ctx.cfg, pos, i, count_lines, shape.count_columns)?;
                     }
                 }
@@ -1421,11 +1422,11 @@ mod grid_spanned {
     {
         let mut used_color = None;
 
-        let pos = (row, 0);
+        let pos = (row, 0).into();
         print_vertical_intersection(f, ctx.cfg, pos, shape, &mut used_color)?;
 
         for col in 0..shape.count_columns {
-            let pos = (row, col);
+            let pos = (row, col).into();
             if ctx.cfg.is_cell_covered_by_both_spans(pos) {
                 continue;
             }
@@ -1448,7 +1449,7 @@ mod grid_spanned {
                         .sum::<usize>();
                 }
 
-                let pos = (original_row, col);
+                let pos = (original_row, col).into();
                 let height = get_cell_height(ctx.cfg, ctx.dims, pos, shape.count_rows);
                 let width = get_cell_width(ctx.cfg, ctx.dims, pos, shape.count_columns);
                 let line = skip_lines;
@@ -1461,7 +1462,7 @@ mod grid_spanned {
                     col += span - 1;
                 }
 
-                let pos = (row, col + 1);
+                let pos = (row, col + 1).into();
                 print_vertical_intersection(f, ctx.cfg, pos, shape, &mut used_color)?;
 
                 continue;
@@ -1481,7 +1482,7 @@ mod grid_spanned {
                 }
             }
 
-            let pos = (row, col + 1);
+            let pos = (row, col + 1).into();
             print_vertical_intersection(f, ctx.cfg, pos, shape, &mut used_color)?;
         }
 
@@ -1549,7 +1550,7 @@ mod grid_spanned {
         //
         // todo: Yes... this check very likely degrages performance a bit,
         //       Surely we need to rethink it.
-        if !cfg.has_vertical(pos.1, shape.count_columns) {
+        if !cfg.has_vertical(pos.col(), shape.count_columns) {
             return Ok(());
         }
 
@@ -1604,14 +1605,14 @@ mod grid_spanned {
         D: Dimension,
     {
         let mut used_color = None;
-        print_vertical_intersection(f, cfg, (row, 0), shape, &mut used_color)?;
+        print_vertical_intersection(f, cfg, (row, 0).into(), shape, &mut used_color)?;
 
         for col in 0..shape.count_columns {
             let width = dimension.get_width(col);
 
             // general case
             if width > 0 {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 let main = cfg.get_horizontal(pos, shape.count_rows);
                 match main {
                     Some(c) => {
@@ -1623,7 +1624,7 @@ mod grid_spanned {
                 }
             }
 
-            let pos = (row, col + 1);
+            let pos = (row, col + 1).into();
             print_vertical_intersection(f, cfg, pos, shape, &mut used_color)?;
         }
 
@@ -2076,11 +2077,11 @@ mod grid_spanned {
     {
         match cfg.get_column_span(pos) {
             Some(span) => {
-                let start = pos.1;
+                let start = pos.col();
                 let end = start + span;
                 range_width(dims, start, end) + count_verticals_range(cfg, start, end, max)
             }
-            None => dims.get_width(pos.1),
+            None => dims.get_width(pos.col()),
         }
     }
 
@@ -2103,11 +2104,11 @@ mod grid_spanned {
     {
         match cfg.get_row_span(pos) {
             Some(span) => {
-                let start = pos.0;
-                let end = pos.0 + span;
+                let start = pos.row();
+                let end = pos.row() + span;
                 range_height(dims, start, end) + count_horizontals_range(cfg, start, end, max)
             }
-            None => dims.get_height(pos.0),
+            None => dims.get_height(pos.row()),
         }
     }
 
@@ -2127,14 +2128,14 @@ mod grid_spanned {
     fn closest_visible_row(cfg: &SpannedConfig, mut pos: Position) -> Option<usize> {
         loop {
             if cfg.is_cell_visible(pos) {
-                return Some(pos.0);
+                return Some(pos.row());
             }
 
-            if pos.0 == 0 {
+            if pos.row() == 0 {
                 return None;
             }
 
-            pos.0 -= 1;
+            pos -= (1, 0);
         }
     }
 
diff --git a/papergrid/src/records/vec_records/mod.rs b/papergrid/src/records/vec_records/mod.rs
index 12cb479..e17b8ef 100644
--- a/papergrid/src/records/vec_records/mod.rs
+++ b/papergrid/src/records/vec_records/mod.rs
@@ -76,24 +76,24 @@ impl<T> PeekableRecords for VecRecords<T>
 where
     T: Cell,
 {
-    fn get_text(&self, (row, col): Position) -> &str {
-        self[row][col].text()
+    fn get_text(&self, pos: Position) -> &str {
+        self[pos.row()][pos.col()].text()
     }
 
-    fn count_lines(&self, (row, col): Position) -> usize {
-        self[row][col].count_lines()
+    fn count_lines(&self, pos: Position) -> usize {
+        self[pos.row()][pos.col()].count_lines()
     }
 
-    fn get_line(&self, (row, col): Position, line: usize) -> &str {
-        self[row][col].line(line)
+    fn get_line(&self, pos: Position, line: usize) -> &str {
+        self[pos.row()][pos.col()].line(line)
     }
 
-    fn get_line_width(&self, (row, col): Position, line: usize) -> usize {
-        self[row][col].line_width(line)
+    fn get_line_width(&self, pos: Position, line: usize) -> usize {
+        self[pos.row()][pos.col()].line_width(line)
     }
 
-    fn get_width(&self, (row, col): Position) -> usize {
-        self[row][col].width()
+    fn get_width(&self, pos: Position) -> usize {
+        self[pos.row()][pos.col()].width()
     }
 }
 
diff --git a/tabled/src/grid/config/colored_config.rs b/tabled/src/grid/config/colored_config.rs
index 93ad790..c9bb908 100644
--- a/tabled/src/grid/config/colored_config.rs
+++ b/tabled/src/grid/config/colored_config.rs
@@ -1,5 +1,7 @@
 use std::ops::{Deref, DerefMut};
 
+use papergrid::config::Position;
+
 use crate::grid::{
     ansi::ANSIBuf,
     config::{Entity, EntityMap, SpannedConfig},
@@ -106,7 +108,7 @@ impl ColorMap {
 impl crate::grid::colors::Colors for ColorMap {
     type Color = ANSIBuf;
 
-    fn get_color(&self, pos: (usize, usize)) -> Option<&Self::Color> {
+    fn get_color(&self, pos: Position) -> Option<&Self::Color> {
         self.0.as_ref().map(|map| map.get(pos))
     }
 
diff --git a/tabled/src/grid/config/compact_multiline_config.rs b/tabled/src/grid/config/compact_multiline_config.rs
index 4211009..6fe9c46 100644
--- a/tabled/src/grid/config/compact_multiline_config.rs
+++ b/tabled/src/grid/config/compact_multiline_config.rs
@@ -44,7 +44,7 @@ impl CompactMultilineConfig {
 
     /// Set grid margin.
     pub fn set_margin(&mut self, margin: Sides<Indent>) {
-        self.config = self.config.set_margin(margin);
+        self.config.set_margin(margin);
     }
 
     /// Returns a grid margin.
@@ -54,7 +54,7 @@ impl CompactMultilineConfig {
 
     /// Set the [`Borders`] value as correct one.
     pub fn set_borders(&mut self, borders: Borders<char>) {
-        self.config = self.config.set_borders(borders)
+        self.config.set_borders(borders)
     }
 
     /// Returns a current [`Borders`] structure.
@@ -69,7 +69,7 @@ impl CompactMultilineConfig {
 
     /// Set a padding to a given cells.
     pub fn set_padding(&mut self, padding: Sides<Indent>) {
-        self.config = self.config.set_padding(padding)
+        self.config.set_padding(padding)
     }
 
     /// Get a padding for a given.
@@ -79,7 +79,7 @@ impl CompactMultilineConfig {
 
     /// Set a horizontal alignment.
     pub fn set_alignment_horizontal(&mut self, alignment: AlignmentHorizontal) {
-        self.config = self.config.set_alignment_horizontal(alignment)
+        self.config.set_alignment_horizontal(alignment)
     }
 
     /// Get a alignment horizontal.
@@ -89,12 +89,12 @@ impl CompactMultilineConfig {
 
     /// Sets colors of border carcass on the grid.
     pub fn set_borders_color(&mut self, borders: Borders<ANSIStr<'static>>) {
-        self.config = self.config.set_borders_color(borders)
+        self.config.set_borders_color(borders)
     }
 
     /// Set colors for a margin.
     pub fn set_margin_color(&mut self, color: Sides<ANSIStr<'static>>) {
-        self.config = self.config.set_margin_color(color)
+        self.config.set_margin_color(color)
     }
 
     /// Returns a margin color.
@@ -104,7 +104,7 @@ impl CompactMultilineConfig {
 
     /// Set a padding color to all cells.
     pub fn set_padding_color(&mut self, color: Sides<ANSIStr<'static>>) {
-        self.config = self.config.set_padding_color(color)
+        self.config.set_padding_color(color)
     }
 
     /// get a padding color.
diff --git a/tabled/src/grid/dimension/peekable_dimension.rs b/tabled/src/grid/dimension/peekable_dimension.rs
index a60b5cf..662a639 100644
--- a/tabled/src/grid/dimension/peekable_dimension.rs
+++ b/tabled/src/grid/dimension/peekable_dimension.rs
@@ -75,7 +75,7 @@ mod estimation {
         for (row, columns) in records.iter_rows().enumerate() {
             let mut row_height = 0;
             for (col, cell) in columns.iter().enumerate() {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 if !cfg.is_cell_visible(pos) {
                     continue;
                 }
@@ -123,17 +123,14 @@ mod estimation {
             return;
         }
 
-        let mut spans_ordered = spans
-            .iter()
-            .map(|(k, v)| ((k.0, k.1), *v))
-            .collect::<Vec<_>>();
+        let mut spans_ordered = spans.iter().map(|(k, v)| (k, *v)).collect::<Vec<_>>();
         spans_ordered.sort_unstable_by(|(arow, acol), (brow, bcol)| match arow.cmp(brow) {
             Ordering::Equal => acol.cmp(bcol),
             ord => ord,
         });
 
-        for ((row, _), (span, height)) in spans_ordered {
-            adjust_row_range(cfg, height, len, row, row + span, heights);
+        for (p, (span, height)) in spans_ordered {
+            adjust_row_range(cfg, height, len, p.row(), p.row() + span, heights);
         }
     }
 
@@ -211,17 +208,14 @@ mod estimation {
         // The overall width distribution will be different depend on the order.
         //
         // We sort spans in order to prioritize the smaller spans first.
-        let mut spans_ordered = spans
-            .iter()
-            .map(|(k, v)| ((k.0, k.1), *v))
-            .collect::<Vec<_>>();
+        let mut spans_ordered = spans.iter().map(|(k, v)| (k, *v)).collect::<Vec<_>>();
         spans_ordered.sort_unstable_by(|a, b| match a.1 .0.cmp(&b.1 .0) {
-            Ordering::Equal => a.0.cmp(&b.0),
+            Ordering::Equal => a.0.cmp(b.0),
             o => o,
         });
 
-        for ((_, col), (span, width)) in spans_ordered {
-            adjust_column_range(cfg, width, len, col, col + span, widths);
+        for (p, (span, width)) in spans_ordered {
+            adjust_column_range(cfg, width, len, p.col(), p.col() + span, widths);
         }
     }
 
@@ -270,7 +264,7 @@ mod estimation {
         for (row, columns) in records.iter_rows().enumerate() {
             let mut row_height = 0;
             for (col, cell) in columns.iter().enumerate() {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 if !cfg.is_cell_visible(pos) {
                     continue;
                 }
@@ -303,7 +297,7 @@ mod estimation {
 
         for (row, columns) in records.iter_rows().enumerate() {
             for (col, cell) in columns.iter().enumerate() {
-                let pos = (row, col);
+                let pos = (row, col).into();
                 if !cfg.is_cell_visible(pos) {
                     continue;
                 }
diff --git a/tabled/src/grid/records/records_mut.rs b/tabled/src/grid/records/records_mut.rs
index 6017b73..f615d97 100644
--- a/tabled/src/grid/records/records_mut.rs
+++ b/tabled/src/grid/records/records_mut.rs
@@ -21,14 +21,14 @@ where
 
 #[cfg(feature = "std")]
 impl RecordsMut<String> for VecRecords<Text<String>> {
-    fn set(&mut self, (row, col): Position, text: String) {
-        self[row][col] = Text::new(text);
+    fn set(&mut self, pos: Position, text: String) {
+        self[pos.row()][pos.col()] = Text::new(text);
     }
 }
 
 #[cfg(feature = "std")]
 impl RecordsMut<&str> for VecRecords<Text<String>> {
-    fn set(&mut self, (row, col): Position, text: &str) {
-        self[row][col] = Text::new(text.to_string());
+    fn set(&mut self, p: Position, text: &str) {
+        self[p.row()][p.col()] = Text::new(text.to_string());
     }
 }
diff --git a/tabled/src/grid/records/resizable.rs b/tabled/src/grid/records/resizable.rs
index 860d611..c2ed98f 100644
--- a/tabled/src/grid/records/resizable.rs
+++ b/tabled/src/grid/records/resizable.rs
@@ -76,9 +76,9 @@ where
             return;
         }
 
-        let t = std::mem::take(&mut self[lhs.0][lhs.1]);
-        let t = std::mem::replace(&mut self[rhs.0][rhs.1], t);
-        let _ = std::mem::replace(&mut self[lhs.0][lhs.1], t);
+        let t = std::mem::take(&mut self[lhs.row()][lhs.col()]);
+        let t = std::mem::replace(&mut self[rhs.row()][rhs.col()], t);
+        let _ = std::mem::replace(&mut self[lhs.row()][lhs.col()], t);
     }
 
     fn swap_row(&mut self, lhs: usize, rhs: usize) {
@@ -136,9 +136,9 @@ where
             return;
         }
 
-        let t = std::mem::take(&mut self[lhs.0][lhs.1]);
-        let t = std::mem::replace(&mut self[rhs.0][rhs.1], t);
-        let _ = std::mem::replace(&mut self[lhs.0][lhs.1], t);
+        let t = std::mem::take(&mut self[lhs.row()][lhs.col()]);
+        let t = std::mem::replace(&mut self[rhs.row()][rhs.col()], t);
+        let _ = std::mem::replace(&mut self[lhs.row()][lhs.col()], t);
     }
 
     fn swap_row(&mut self, lhs: usize, rhs: usize) {
diff --git a/tabled/src/settings/alignment/mod.rs b/tabled/src/settings/alignment/mod.rs
index d675e23..b142d04 100644
--- a/tabled/src/settings/alignment/mod.rs
+++ b/tabled/src/settings/alignment/mod.rs
@@ -195,7 +195,7 @@ impl<R, D> TableOption<R, ColoredConfig, D> for Alignment {
 impl<R, D> TableOption<R, CompactConfig, D> for Alignment {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
         if let Horizontal(a) = self.inner {
-            *cfg = cfg.set_alignment_horizontal(a)
+            cfg.set_alignment_horizontal(a)
         }
     }
 
diff --git a/tabled/src/settings/concat/mod.rs b/tabled/src/settings/concat/mod.rs
index 18284ba..cf3082d 100644
--- a/tabled/src/settings/concat/mod.rs
+++ b/tabled/src/settings/concat/mod.rs
@@ -13,6 +13,8 @@
 
 use std::borrow::Cow;
 
+use papergrid::config::pos;
+
 use crate::{
     grid::records::{ExactRecords, PeekableRecords, Records, RecordsMut, Resizable},
     settings::TableOption,
@@ -136,15 +138,15 @@ where
                     records.push_row();
 
                     for col in 0..records.count_columns() {
-                        records.set((row, col), self.default_cell.to_string());
+                        records.set(pos(row, col), self.default_cell.to_string());
                     }
                 }
 
                 for row in 0..rhs.shape().0 {
                     for col in 0..rhs.shape().1 {
-                        let text = rhs.get_records().get_text((row, col)).to_string();
+                        let text = rhs.get_records().get_text(pos(row, col)).to_string();
                         let col = col + count_cols;
-                        records.set((row, col), text);
+                        records.set((row, col).into(), text);
                     }
                 }
             }
@@ -157,15 +159,15 @@ where
                     records.push_column();
 
                     for row in 0..records.count_rows() {
-                        records.set((row, col), self.default_cell.to_string());
+                        records.set(pos(row, col), self.default_cell.to_string());
                     }
                 }
 
                 for row in 0..rhs.shape().0 {
                     for col in 0..rhs.shape().1 {
-                        let text = rhs.get_records().get_text((row, col)).to_string();
+                        let text = rhs.get_records().get_text(pos(row, col)).to_string();
                         let row = row + count_rows;
-                        records.set((row, col), text);
+                        records.set(pos(row, col), text);
                     }
                 }
             }
diff --git a/tabled/src/settings/duplicate/mod.rs b/tabled/src/settings/duplicate/mod.rs
index 0701281..8b9dcdf 100644
--- a/tabled/src/settings/duplicate/mod.rs
+++ b/tabled/src/settings/duplicate/mod.rs
@@ -136,12 +136,12 @@ where
     }
 }
 
-fn is_valid_cell((row, col): Position, count_rows: usize, count_columns: usize) -> bool {
-    if row > count_rows {
+fn is_valid_cell(pos: Position, count_rows: usize, count_columns: usize) -> bool {
+    if pos.row() > count_rows {
         return false;
     }
 
-    if col > count_columns {
+    if pos.col() > count_columns {
         return false;
     }
 
diff --git a/tabled/src/settings/format/format_content.rs b/tabled/src/settings/format/format_content.rs
index b6263b5..e1e66f6 100644
--- a/tabled/src/settings/format/format_content.rs
+++ b/tabled/src/settings/format/format_content.rs
@@ -58,8 +58,7 @@ where
         let count_cols = records.count_columns();
 
         for pos in entity.iter(count_rows, count_cols) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_cols;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_cols).into()) {
                 continue;
             }
 
diff --git a/tabled/src/settings/format/format_positioned.rs b/tabled/src/settings/format/format_positioned.rs
index c2936db..c02f4ef 100644
--- a/tabled/src/settings/format/format_positioned.rs
+++ b/tabled/src/settings/format/format_positioned.rs
@@ -1,3 +1,5 @@
+use papergrid::config::Position;
+
 use crate::{
     grid::config::Entity,
     grid::records::{ExactRecords, PeekableRecords, Records, RecordsMut},
@@ -20,7 +22,7 @@ impl<F> FormatContentPositioned<F> {
 
 impl<F, R, D, C> TableOption<R, C, D> for FormatContentPositioned<F>
 where
-    F: FnMut(&str, (usize, usize)) -> String,
+    F: FnMut(&str, Position) -> String,
     R: Records + ExactRecords + PeekableRecords + RecordsMut<String>,
 {
     fn change(self, records: &mut R, cfg: &mut C, _: &mut D) {
@@ -30,7 +32,7 @@ where
 
 impl<F, R, C> CellOption<R, C> for FormatContentPositioned<F>
 where
-    F: FnMut(&str, (usize, usize)) -> String,
+    F: FnMut(&str, Position) -> String,
     R: Records + ExactRecords + PeekableRecords + RecordsMut<String>,
 {
     fn change(mut self, records: &mut R, _: &mut C, entity: Entity) {
@@ -38,8 +40,7 @@ where
         let count_cols = records.count_columns();
 
         for pos in entity.iter(count_rows, count_cols) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_cols;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_cols).into()) {
                 continue;
             }
 
diff --git a/tabled/src/settings/format/mod.rs b/tabled/src/settings/format/mod.rs
index e8221ae..28aa96c 100644
--- a/tabled/src/settings/format/mod.rs
+++ b/tabled/src/settings/format/mod.rs
@@ -9,6 +9,7 @@ mod format_positioned;
 pub use format_config::FormatConfig;
 pub use format_content::FormatContent;
 pub use format_positioned::FormatContentPositioned;
+use papergrid::config::Position;
 
 /// A formatting function of particular cells on a [`Table`].
 ///
@@ -76,7 +77,7 @@ impl Format {
     /// ];
     ///
     /// let table = Table::new(&data)
-    ///                .with(Modify::new(Rows::single(0)).with(Format::positioned(|_, (_, col)| col.to_string())))
+    ///                .modify(Rows::single(0), Format::positioned(|_, p| p.col().to_string()))
     ///                .to_string();
     ///
     /// assert_eq!(
@@ -96,7 +97,7 @@ impl Format {
     /// ```
     pub fn positioned<F>(f: F) -> FormatContentPositioned<F>
     where
-        F: FnMut(&str, (usize, usize)) -> String,
+        F: FnMut(&str, Position) -> String,
     {
         FormatContentPositioned::new(f)
     }
@@ -142,3 +143,5 @@ impl Format {
         FormatConfig(f)
     }
 }
+
+// todo: Add a lambda with all arguments
diff --git a/tabled/src/settings/formatting/charset.rs b/tabled/src/settings/formatting/charset.rs
index 07cf353..9c3ba9d 100644
--- a/tabled/src/settings/formatting/charset.rs
+++ b/tabled/src/settings/formatting/charset.rs
@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use papergrid::config::pos;
+
 use crate::{
     grid::config::Entity,
     grid::records::{ExactRecords, PeekableRecords, Records, RecordsMut},
@@ -101,7 +103,7 @@ where
     fn change(self, records: &mut R, _: &mut C, _: &mut D) {
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let pos = (row, col);
+                let pos = pos(row, col);
                 let text = records.get_text(pos);
                 let text = clean_charset(text);
                 records.set(pos, text);
diff --git a/tabled/src/settings/formatting/tab_size.rs b/tabled/src/settings/formatting/tab_size.rs
index 5abf3ac..ee39ab5 100644
--- a/tabled/src/settings/formatting/tab_size.rs
+++ b/tabled/src/settings/formatting/tab_size.rs
@@ -1,3 +1,5 @@
+use papergrid::config::pos;
+
 use crate::{
     grid::records::{ExactRecords, PeekableRecords, Records, RecordsMut},
     settings::TableOption,
@@ -50,7 +52,7 @@ where
 
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let pos = (row, col);
+                let pos = pos(row, col);
                 let text = records.get_text(pos);
                 let text = text.replace('\t', &" ".repeat(tab_size));
                 records.set(pos, text);
diff --git a/tabled/src/settings/height/cell_height_increase.rs b/tabled/src/settings/height/cell_height_increase.rs
index d4d5ff7..721aaac 100644
--- a/tabled/src/settings/height/cell_height_increase.rs
+++ b/tabled/src/settings/height/cell_height_increase.rs
@@ -54,8 +54,7 @@ where
         let count_columns = records.count_columns();
 
         for pos in entity.iter(count_rows, count_columns) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_columns;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_columns).into()) {
                 continue;
             }
 
diff --git a/tabled/src/settings/height/cell_height_limit.rs b/tabled/src/settings/height/cell_height_limit.rs
index 1bd5236..cb5c52e 100644
--- a/tabled/src/settings/height/cell_height_limit.rs
+++ b/tabled/src/settings/height/cell_height_limit.rs
@@ -54,8 +54,7 @@ where
         let count_columns = records.count_columns();
 
         for pos in entity.iter(count_rows, count_columns) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_columns;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_columns).into()) {
                 continue;
             }
 
diff --git a/tabled/src/settings/height/table_height_limit.rs b/tabled/src/settings/height/table_height_limit.rs
index 2115fc0..b4b910c 100644
--- a/tabled/src/settings/height/table_height_limit.rs
+++ b/tabled/src/settings/height/table_height_limit.rs
@@ -77,7 +77,7 @@ where
 
         for (row, &height) in heights.iter().enumerate() {
             for col in 0..count_cols {
-                let text = records.get_text((row, col));
+                let text = records.get_text((row, col).into());
                 let count_lines = count_lines(text);
 
                 if count_lines <= height {
@@ -86,7 +86,7 @@ where
 
                 let text = limit_lines(text, height);
 
-                records.set((row, col), text);
+                records.set((row, col).into(), text);
             }
         }
 
diff --git a/tabled/src/settings/highlight/mod.rs b/tabled/src/settings/highlight/mod.rs
index 6a61ab0..89b0306 100644
--- a/tabled/src/settings/highlight/mod.rs
+++ b/tabled/src/settings/highlight/mod.rs
@@ -172,9 +172,9 @@ fn set_border_color(cfg: &mut SpannedConfig, sector: &HashSet<Position>, border:
         return;
     }
     let color = border.clone();
-    for &(row, col) in sector {
-        let border = build_cell_border(sector, (row, col), &color);
-        cfg.set_border_color((row, col), border);
+    for &p in sector {
+        let border = build_cell_border(sector, p, &color);
+        cfg.set_border_color(p, border);
     }
 }
 
@@ -223,21 +223,23 @@ fn split_segments(
     squashed_segments
 }
 
-fn is_cell_connected((row1, col1): Position, (row2, col2): Position) -> bool {
-    if col1 == col2 && row1 == row2 + 1 {
-        return true;
-    }
+fn is_cell_connected(p1: Position, p2: Position) -> bool {
+    if p1.col() == p2.col() {
+        let up = p1.row() == p2.row() + 1;
+        let down = p2.row() > 0 && p1.row() == p2.row() - 1;
 
-    if col1 == col2 && (row2 > 0 && row1 == row2 - 1) {
-        return true;
+        if up || down {
+            return true;
+        }
     }
 
-    if row1 == row2 && col1 == col2 + 1 {
-        return true;
-    }
+    if p1.row() == p2.row() {
+        let left = p2.col() > 0 && p1.col() == p2.col() - 1;
+        let right = p1.col() == p2.col() + 1;
 
-    if row1 == row2 && (col2 > 0 && col1 == col2 - 1) {
-        return true;
+        if left || right {
+            return true;
+        }
     }
 
     false
@@ -266,188 +268,194 @@ fn set_border(cfg: &mut SpannedConfig, sector: &HashSet<Position>, border: Borde
     }
 }
 
-fn build_cell_border<T>(
-    sector: &HashSet<Position>,
-    (row, col): Position,
-    border: &Border<T>,
-) -> Border<T>
+fn build_cell_border<T>(sector: &HashSet<Position>, p: Position, border: &Border<T>) -> Border<T>
 where
     T: Default + Clone,
 {
-    let cell_has_top_neighbor = cell_has_top_neighbor(sector, row, col);
-    let cell_has_bottom_neighbor = cell_has_bottom_neighbor(sector, row, col);
-    let cell_has_left_neighbor = cell_has_left_neighbor(sector, row, col);
-    let cell_has_right_neighbor = cell_has_right_neighbor(sector, row, col);
+    let has_top_neighbor = has_top_neighbor(sector, p);
+    let has_bottom_neighbor = has_bottom_neighbor(sector, p);
+    let has_left_neighbor = has_left_neighbor(sector, p);
+    let has_right_neighbor = has_right_neighbor(sector, p);
+    let has_left_top_neighbor = has_left_top_neighbor(sector, p);
+    let has_right_top_neighbor = has_right_top_neighbor(sector, p);
+    let has_left_bottom_neighbor = has_left_bottom_neighbor(sector, p);
+    let has_right_bottom_neighbor = has_right_bottom_neighbor(sector, p);
 
-    let this_has_left_top_neighbor = is_there_left_top_cell(sector, row, col);
-    let this_has_right_top_neighbor = is_there_right_top_cell(sector, row, col);
-    let this_has_left_bottom_neighbor = is_there_left_bottom_cell(sector, row, col);
-    let this_has_right_bottom_neighbor = is_there_right_bottom_cell(sector, row, col);
+    let mut b = Border::default();
 
-    let mut cell_border = Border::default();
     if let Some(c) = border.top.clone() {
-        if !cell_has_top_neighbor {
-            cell_border.top = Some(c.clone());
+        if !has_top_neighbor {
+            b.top = Some(c.clone());
 
-            if cell_has_right_neighbor && !this_has_right_top_neighbor {
-                cell_border.right_top_corner = Some(c);
+            if has_right_neighbor && !has_right_top_neighbor {
+                b.right_top_corner = Some(c);
             }
         }
     }
+
     if let Some(c) = border.bottom.clone() {
-        if !cell_has_bottom_neighbor {
-            cell_border.bottom = Some(c.clone());
+        if !has_bottom_neighbor {
+            b.bottom = Some(c.clone());
 
-            if cell_has_right_neighbor && !this_has_right_bottom_neighbor {
-                cell_border.right_bottom_corner = Some(c);
+            if has_right_neighbor && !has_right_bottom_neighbor {
+                b.right_bottom_corner = Some(c);
             }
         }
     }
+
     if let Some(c) = border.left.clone() {
-        if !cell_has_left_neighbor {
-            cell_border.left = Some(c.clone());
+        if !has_left_neighbor {
+            b.left = Some(c.clone());
 
-            if cell_has_bottom_neighbor && !this_has_left_bottom_neighbor {
-                cell_border.left_bottom_corner = Some(c);
+            if has_bottom_neighbor && !has_left_bottom_neighbor {
+                b.left_bottom_corner = Some(c);
             }
         }
     }
+
     if let Some(c) = border.right.clone() {
-        if !cell_has_right_neighbor {
-            cell_border.right = Some(c.clone());
+        if !has_right_neighbor {
+            b.right = Some(c.clone());
 
-            if cell_has_bottom_neighbor && !this_has_right_bottom_neighbor {
-                cell_border.right_bottom_corner = Some(c);
+            if has_bottom_neighbor && !has_right_bottom_neighbor {
+                b.right_bottom_corner = Some(c);
             }
         }
     }
+
     if let Some(c) = border.left_top_corner.clone() {
-        if !cell_has_left_neighbor && !cell_has_top_neighbor {
-            cell_border.left_top_corner = Some(c);
+        if !has_left_neighbor && !has_top_neighbor {
+            b.left_top_corner = Some(c);
         }
     }
+
     if let Some(c) = border.left_bottom_corner.clone() {
-        if !cell_has_left_neighbor && !cell_has_bottom_neighbor {
-            cell_border.left_bottom_corner = Some(c);
+        if !has_left_neighbor && !has_bottom_neighbor {
+            b.left_bottom_corner = Some(c);
         }
     }
+
     if let Some(c) = border.right_top_corner.clone() {
-        if !cell_has_right_neighbor && !cell_has_top_neighbor {
-            cell_border.right_top_corner = Some(c);
+        if !has_right_neighbor && !has_top_neighbor {
+            b.right_top_corner = Some(c);
         }
     }
+
     if let Some(c) = border.right_bottom_corner.clone() {
-        if !cell_has_right_neighbor && !cell_has_bottom_neighbor {
-            cell_border.right_bottom_corner = Some(c);
+        if !has_right_neighbor && !has_bottom_neighbor {
+            b.right_bottom_corner = Some(c);
         }
     }
+
     {
-        if !cell_has_bottom_neighbor {
-            if !cell_has_left_neighbor && this_has_left_top_neighbor {
+        if !has_bottom_neighbor {
+            if !has_left_neighbor && has_left_top_neighbor {
                 if let Some(c) = border.right_top_corner.clone() {
-                    cell_border.left_top_corner = Some(c);
+                    b.left_top_corner = Some(c);
                 }
             }
 
-            if cell_has_left_neighbor && this_has_left_bottom_neighbor {
+            if has_left_neighbor && has_left_bottom_neighbor {
                 if let Some(c) = border.left_top_corner.clone() {
-                    cell_border.left_bottom_corner = Some(c);
+                    b.left_bottom_corner = Some(c);
                 }
             }
 
-            if !cell_has_right_neighbor && this_has_right_top_neighbor {
+            if !has_right_neighbor && has_right_top_neighbor {
                 if let Some(c) = border.left_top_corner.clone() {
-                    cell_border.right_top_corner = Some(c);
+                    b.right_top_corner = Some(c);
                 }
             }
 
-            if cell_has_right_neighbor && this_has_right_bottom_neighbor {
+            if has_right_neighbor && has_right_bottom_neighbor {
                 if let Some(c) = border.right_top_corner.clone() {
-                    cell_border.right_bottom_corner = Some(c);
+                    b.right_bottom_corner = Some(c);
                 }
             }
         }
 
-        if !cell_has_top_neighbor {
-            if !cell_has_left_neighbor && this_has_left_bottom_neighbor {
+        if !has_top_neighbor {
+            if !has_left_neighbor && has_left_bottom_neighbor {
                 if let Some(c) = border.right_bottom_corner.clone() {
-                    cell_border.left_bottom_corner = Some(c);
+                    b.left_bottom_corner = Some(c);
                 }
             }
 
-            if cell_has_left_neighbor && this_has_left_top_neighbor {
+            if has_left_neighbor && has_left_top_neighbor {
                 if let Some(c) = border.left_bottom_corner.clone() {
-                    cell_border.left_top_corner = Some(c);
+                    b.left_top_corner = Some(c);
                 }
             }
 
-            if !cell_has_right_neighbor && this_has_right_bottom_neighbor {
+            if !has_right_neighbor && has_right_bottom_neighbor {
                 if let Some(c) = border.left_bottom_corner.clone() {
-                    cell_border.right_bottom_corner = Some(c);
+                    b.right_bottom_corner = Some(c);
                 }
             }
 
-            if cell_has_right_neighbor && this_has_right_top_neighbor {
+            if has_right_neighbor && has_right_top_neighbor {
                 if let Some(c) = border.right_bottom_corner.clone() {
-                    cell_border.right_top_corner = Some(c);
+                    b.right_top_corner = Some(c);
                 }
             }
         }
     }
 
-    cell_border
+    b
 }
 
-fn cell_has_top_neighbor(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    row > 0 && sector.contains(&(row - 1, col))
+fn has_top_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    p.row() > 0 && sector.contains(&(p - (1, 0)))
 }
 
-fn cell_has_bottom_neighbor(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    sector.contains(&(row + 1, col))
+fn has_bottom_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    sector.contains(&(p + (1, 0)))
 }
 
-fn cell_has_left_neighbor(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    col > 0 && sector.contains(&(row, col - 1))
+fn has_left_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    p.col() > 0 && sector.contains(&(p - (0, 1)))
 }
 
-fn cell_has_right_neighbor(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    sector.contains(&(row, col + 1))
+fn has_right_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    sector.contains(&(p + (0, 1)))
 }
 
-fn is_there_left_top_cell(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    row > 0 && col > 0 && sector.contains(&(row - 1, col - 1))
+fn has_left_top_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    p.row() > 0 && p.col() > 0 && sector.contains(&(p - (1, 1)))
 }
 
-fn is_there_right_top_cell(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    row > 0 && sector.contains(&(row - 1, col + 1))
+fn has_right_top_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    p.row() > 0 && sector.contains(&(p - (1, 0) + (0, 1)))
 }
 
-fn is_there_left_bottom_cell(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    col > 0 && sector.contains(&(row + 1, col - 1))
+fn has_left_bottom_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    p.col() > 0 && sector.contains(&(p + (1, 0) - (0, 1)))
 }
 
-fn is_there_right_bottom_cell(sector: &HashSet<Position>, row: usize, col: usize) -> bool {
-    sector.contains(&(row + 1, col + 1))
+fn has_right_bottom_neighbor(sector: &HashSet<Position>, p: Position) -> bool {
+    sector.contains(&(p + (1, 1)))
 }
 
 #[cfg(test)]
 mod tests {
+    use papergrid::config::pos;
+
     use super::*;
 
     #[test]
     fn test_is_connected() {
-        assert!(is_cell_connected((0, 0), (0, 1)));
-        assert!(is_cell_connected((0, 0), (1, 0)));
-        assert!(!is_cell_connected((0, 0), (1, 1)));
-
-        assert!(is_cell_connected((0, 1), (0, 0)));
-        assert!(is_cell_connected((1, 0), (0, 0)));
-        assert!(!is_cell_connected((1, 1), (0, 0)));
-
-        assert!(is_cell_connected((1, 1), (0, 1)));
-        assert!(is_cell_connected((1, 1), (1, 0)));
-        assert!(is_cell_connected((1, 1), (2, 1)));
-        assert!(is_cell_connected((1, 1), (1, 2)));
-        assert!(!is_cell_connected((1, 1), (1, 1)));
+        assert!(is_cell_connected(pos(0, 0), pos(0, 1)));
+        assert!(is_cell_connected(pos(0, 0), pos(1, 0)));
+        assert!(!is_cell_connected(pos(0, 0), pos(1, 1)));
+
+        assert!(is_cell_connected(pos(0, 1), pos(0, 0)));
+        assert!(is_cell_connected(pos(1, 0), pos(0, 0)));
+        assert!(!is_cell_connected(pos(1, 1), pos(0, 0)));
+
+        assert!(is_cell_connected(pos(1, 1), pos(0, 1)));
+        assert!(is_cell_connected(pos(1, 1), pos(1, 0)));
+        assert!(is_cell_connected(pos(1, 1), pos(2, 1)));
+        assert!(is_cell_connected(pos(1, 1), pos(1, 2)));
+        assert!(!is_cell_connected(pos(1, 1), pos(1, 1)));
     }
 }
diff --git a/tabled/src/settings/location/by_column_name.rs b/tabled/src/settings/location/by_column_name.rs
index eafb828..22316a1 100644
--- a/tabled/src/settings/location/by_column_name.rs
+++ b/tabled/src/settings/location/by_column_name.rs
@@ -33,7 +33,7 @@ where
     fn locate(&mut self, records: &R) -> Self::IntoIter {
         // todo: can be optimized by creating Iterator
         (0..records.count_columns())
-            .filter(|col| records.get_text((0, *col)) == self.0.as_ref())
+            .filter(|col| records.get_text((0, *col).into()) == self.0.as_ref())
             .collect::<Vec<_>>()
     }
 }
@@ -48,7 +48,7 @@ where
     fn cells(&self, records: &R) -> Self::Iter {
         // todo: can be optimized by creating Iterator
         (0..records.count_columns())
-            .filter(|col| records.get_text((0, *col)) == self.0.as_ref())
+            .filter(|col| records.get_text((0, *col).into()) == self.0.as_ref())
             .map(Entity::Column)
             .collect::<Vec<_>>()
             .into_iter()
diff --git a/tabled/src/settings/location/by_condition.rs b/tabled/src/settings/location/by_condition.rs
index f37a0ea..d116d33 100644
--- a/tabled/src/settings/location/by_condition.rs
+++ b/tabled/src/settings/location/by_condition.rs
@@ -37,9 +37,9 @@ where
         let mut out = vec![];
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let text = records.get_text((row, col));
+                let text = records.get_text((row, col).into());
                 if cond(text) {
-                    out.push((row, col));
+                    out.push((row, col).into());
                 }
             }
         }
@@ -62,7 +62,7 @@ where
         let mut out = vec![];
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let text = records.get_text((row, col));
+                let text = records.get_text((row, col).into());
                 if cond(text) {
                     out.push(Entity::Cell(row, col));
                 }
diff --git a/tabled/src/settings/location/by_content.rs b/tabled/src/settings/location/by_content.rs
index df990e3..e810140 100644
--- a/tabled/src/settings/location/by_content.rs
+++ b/tabled/src/settings/location/by_content.rs
@@ -37,9 +37,9 @@ where
         let mut out = vec![];
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let cell = records.get_text((row, col));
+                let cell = records.get_text((row, col).into());
                 if cell.eq(text) {
-                    out.push((row, col));
+                    out.push((row, col).into());
                 }
             }
         }
@@ -62,7 +62,7 @@ where
         let mut out = vec![];
         for row in 0..records.count_rows() {
             for col in 0..records.count_columns() {
-                let cell = records.get_text((row, col));
+                let cell = records.get_text((row, col).into());
                 if cell.eq(text) {
                     out.push(Entity::Cell(row, col));
                 }
diff --git a/tabled/src/settings/margin/mod.rs b/tabled/src/settings/margin/mod.rs
index 7357c42..3b791c7 100644
--- a/tabled/src/settings/margin/mod.rs
+++ b/tabled/src/settings/margin/mod.rs
@@ -104,7 +104,7 @@ impl<R, D> TableOption<R, ColoredConfig, D> for Margin {
 
 impl<R, D> TableOption<R, CompactConfig, D> for Margin {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
-        *cfg = cfg.set_margin(self.indent);
+        cfg.set_margin(self.indent);
     }
 }
 
diff --git a/tabled/src/settings/margin_color/mod.rs b/tabled/src/settings/margin_color/mod.rs
index 6b81105..6a13aac 100644
--- a/tabled/src/settings/margin_color/mod.rs
+++ b/tabled/src/settings/margin_color/mod.rs
@@ -103,7 +103,7 @@ where
 {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
         let colors = self.colors.convert_into();
-        *cfg = cfg.set_margin_color(colors);
+        cfg.set_margin_color(colors);
     }
 }
 
diff --git a/tabled/src/settings/measurement/mod.rs b/tabled/src/settings/measurement/mod.rs
index d5bb463..fe85baf 100644
--- a/tabled/src/settings/measurement/mod.rs
+++ b/tabled/src/settings/measurement/mod.rs
@@ -119,7 +119,7 @@ where
 {
     let (count_rows, count_cols) = (records.count_rows(), records.count_columns());
     (0..count_rows).map(move |row| {
-        (0..count_cols).map(move |col| get_text_width(records.get_text((row, col))))
+        (0..count_cols).map(move |col| get_text_width(records.get_text((row, col).into())))
     })
 }
 
@@ -129,6 +129,6 @@ where
 {
     (0..records.count_rows()).map(move |row| {
         (0..records.count_columns())
-            .map(move |col| string::count_lines(records.get_text((row, col))))
+            .map(move |col| string::count_lines(records.get_text((row, col).into())))
     })
 }
diff --git a/tabled/src/settings/merge/mod.rs b/tabled/src/settings/merge/mod.rs
index 1e1ea7a..21458c7 100644
--- a/tabled/src/settings/merge/mod.rs
+++ b/tabled/src/settings/merge/mod.rs
@@ -61,8 +61,8 @@ where
                 }
 
                 // we need to mitigate messing existing spans
-                let is_cell_visible = cfg.is_cell_visible((row, column));
-                let is_row_span_cell = cfg.get_column_span((row, column)).is_some();
+                let is_cell_visible = cfg.is_cell_visible((row, column).into());
+                let is_row_span_cell = cfg.get_column_span((row, column).into()).is_some();
 
                 if !repeat_is_set {
                     if !is_cell_visible {
@@ -74,7 +74,7 @@ where
                     }
 
                     repeat_length = 1;
-                    repeat_value = records.get_text((row, column)).to_owned();
+                    repeat_value = records.get_text((row, column).into()).to_owned();
                     repeat_is_set = true;
                     continue;
                 }
@@ -90,7 +90,7 @@ where
                     continue;
                 }
 
-                let text = records.get_text((row, column));
+                let text = records.get_text((row, column).into());
                 let is_duplicate = text == repeat_value;
 
                 if is_duplicate {
@@ -99,15 +99,15 @@ where
                 }
 
                 if repeat_length > 1 {
-                    cfg.set_row_span((row + 1, column), repeat_length);
+                    cfg.set_row_span((row + 1, column).into(), repeat_length);
                 }
 
                 repeat_length = 1;
-                repeat_value = records.get_text((row, column)).to_owned();
+                repeat_value = records.get_text((row, column).into()).to_owned();
             }
 
             if repeat_length > 1 {
-                cfg.set_row_span((0, column), repeat_length);
+                cfg.set_row_span((0, column).into(), repeat_length);
             }
         }
     }
@@ -149,8 +149,8 @@ where
                 }
 
                 // we need to mitigate messing existing spans
-                let is_cell_visible = cfg.is_cell_visible((row, column));
-                let is_col_span_cell = cfg.get_row_span((row, column)).is_some();
+                let is_cell_visible = cfg.is_cell_visible((row, column).into());
+                let is_col_span_cell = cfg.get_row_span((row, column).into()).is_some();
 
                 if !repeat_is_set {
                     if !is_cell_visible {
@@ -162,7 +162,7 @@ where
                     }
 
                     repeat_length = 1;
-                    repeat_value = records.get_text((row, column)).to_owned();
+                    repeat_value = records.get_text((row, column).into()).to_owned();
                     repeat_is_set = true;
                     continue;
                 }
@@ -178,7 +178,7 @@ where
                     continue;
                 }
 
-                let text = records.get_text((row, column));
+                let text = records.get_text((row, column).into());
                 let is_duplicate = text == repeat_value;
 
                 if is_duplicate {
@@ -187,15 +187,15 @@ where
                 }
 
                 if repeat_length > 1 {
-                    cfg.set_column_span((row, column + 1), repeat_length);
+                    cfg.set_column_span((row, column + 1).into(), repeat_length);
                 }
 
                 repeat_length = 1;
-                repeat_value = records.get_text((row, column)).to_owned();
+                repeat_value = records.get_text((row, column).into()).to_owned();
             }
 
             if repeat_length > 1 {
-                cfg.set_column_span((row, 0), repeat_length);
+                cfg.set_column_span((row, 0).into(), repeat_length);
             }
         }
     }
diff --git a/tabled/src/settings/object/cell.rs b/tabled/src/settings/object/cell.rs
index 693624b..6c8d3be 100644
--- a/tabled/src/settings/object/cell.rs
+++ b/tabled/src/settings/object/cell.rs
@@ -28,14 +28,20 @@ impl Cell {
 }
 
 impl From<Position> for Cell {
-    fn from((row, col): Position) -> Self {
-        Self(row, col)
+    fn from(pos: Position) -> Self {
+        Self(pos.row(), pos.col())
+    }
+}
+
+impl From<(usize, usize)> for Cell {
+    fn from(pos: (usize, usize)) -> Self {
+        Self(pos.0, pos.1)
     }
 }
 
 impl From<Cell> for Position {
     fn from(Cell(row, col): Cell) -> Self {
-        (row, col)
+        Position::new(row, col)
     }
 }
 
@@ -50,6 +56,14 @@ impl<I> Object<I> for Cell {
 impl<I> Object<I> for Position {
     type Iter = EntityOnce;
 
+    fn cells(&self, _: &I) -> Self::Iter {
+        EntityOnce::new(Some(Entity::Cell(self.row(), self.col())))
+    }
+}
+
+impl<I> Object<I> for (usize, usize) {
+    type Iter = EntityOnce;
+
     fn cells(&self, _: &I) -> Self::Iter {
         EntityOnce::new(Some(Entity::Cell(self.0, self.1)))
     }
diff --git a/tabled/src/settings/object/mod.rs b/tabled/src/settings/object/mod.rs
index bedc5e4..8bd2d3f 100644
--- a/tabled/src/settings/object/mod.rs
+++ b/tabled/src/settings/object/mod.rs
@@ -28,6 +28,7 @@ pub use iterator::{
     FilterObject, FilterObjectIter, ObjectIterator, SkipObject, SkipObjectIter, StepByObject,
     StepByObjectIter,
 };
+use papergrid::config::Position;
 pub use rows::{FirstRow, LastRow, LastRowOffset, Row, Rows, RowsIter};
 pub use segment::{SectorIter, Segment, SegmentAll};
 
@@ -224,7 +225,7 @@ where
 pub struct UnionIter<L, R> {
     lhs: Option<L>,
     rhs: R,
-    seen: HashSet<(usize, usize)>,
+    seen: HashSet<Position>,
     current: Option<EntityIterator>,
     count_rows: usize,
     count_cols: usize,
@@ -267,7 +268,8 @@ where
                 }
 
                 let _ = self.seen.insert(p);
-                return Some(Entity::Cell(p.0, p.1));
+
+                return Some(p.into());
             }
         }
 
@@ -277,7 +279,8 @@ where
                 if let Some(p) = iter.by_ref().next() {
                     let _ = self.seen.insert(p);
                     self.current = Some(iter);
-                    return Some(Entity::Cell(p.0, p.1));
+
+                    return Some(p.into());
                 }
             }
 
@@ -291,7 +294,8 @@ where
                 if !self.seen.contains(&p) {
                     let _ = self.seen.insert(p);
                     self.current = Some(iter);
-                    return Some(Entity::Cell(p.0, p.1));
+
+                    return Some(p.into());
                 }
             }
         }
@@ -304,7 +308,7 @@ where
 #[derive(Debug)]
 pub struct DiffIter<L> {
     lhs: L,
-    seen: HashSet<(usize, usize)>,
+    seen: HashSet<Position>,
     count_rows: usize,
     count_cols: usize,
     current: Option<EntityIterator>,
@@ -348,7 +352,7 @@ where
         if let Some(iter) = self.current.as_mut() {
             for p in iter.by_ref() {
                 if !self.seen.contains(&p) {
-                    return Some(Entity::Cell(p.0, p.1));
+                    return Some(p.into());
                 }
             }
         }
@@ -359,7 +363,7 @@ where
             for p in iter.by_ref() {
                 if !self.seen.contains(&p) {
                     self.current = Some(iter);
-                    return Some(Entity::Cell(p.0, p.1));
+                    return Some(p.into());
                 }
             }
         }
@@ -372,7 +376,7 @@ where
 #[derive(Debug)]
 pub struct IntersectIter<L> {
     lhs: L,
-    seen: HashSet<(usize, usize)>,
+    seen: HashSet<Position>,
     count_rows: usize,
     count_cols: usize,
     current: Option<EntityIterator>,
@@ -416,7 +420,7 @@ where
         if let Some(iter) = self.current.as_mut() {
             for p in iter.by_ref() {
                 if self.seen.contains(&p) {
-                    return Some(Entity::Cell(p.0, p.1));
+                    return Some(p.into());
                 }
             }
         }
@@ -427,7 +431,7 @@ where
             for p in iter.by_ref() {
                 if self.seen.contains(&p) {
                     self.current = Some(iter);
-                    return Some(Entity::Cell(p.0, p.1));
+                    return Some(p.into());
                 }
             }
         }
@@ -440,7 +444,7 @@ where
 #[derive(Debug)]
 pub struct InversionIter {
     all: SectorCellsIter,
-    seen: HashSet<(usize, usize)>,
+    seen: HashSet<Position>,
 }
 
 impl InversionIter {
@@ -470,7 +474,7 @@ impl Iterator for InversionIter {
     fn next(&mut self) -> Option<Self::Item> {
         for p in self.all.by_ref() {
             if !self.seen.contains(&p) {
-                return Some(Entity::Cell(p.0, p.1));
+                return Some(p.into());
             }
         }
 
diff --git a/tabled/src/settings/object/segment.rs b/tabled/src/settings/object/segment.rs
index 9b59ada..20ee4a3 100644
--- a/tabled/src/settings/object/segment.rs
+++ b/tabled/src/settings/object/segment.rs
@@ -1,5 +1,7 @@
 use std::ops::{RangeBounds, RangeFull};
 
+use papergrid::config::Position;
+
 use crate::{
     grid::config::Entity,
     grid::records::{ExactRecords, Records},
@@ -92,8 +94,7 @@ impl Iterator for SectorIter {
     type Item = Entity;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let (row, col) = self.iter.next()?;
-        Some(Entity::Cell(row, col))
+        self.iter.next().map(Into::into)
     }
 }
 
@@ -125,7 +126,7 @@ impl SectorCellsIter {
 }
 
 impl Iterator for SectorCellsIter {
-    type Item = (usize, usize);
+    type Item = Position;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.row >= self.rows_end {
@@ -146,6 +147,6 @@ impl Iterator for SectorCellsIter {
             self.col = self.cols_start;
         }
 
-        Some((row, col))
+        Some((row, col).into())
     }
 }
diff --git a/tabled/src/settings/padding/mod.rs b/tabled/src/settings/padding/mod.rs
index e6a7e09..5ccf8aa 100644
--- a/tabled/src/settings/padding/mod.rs
+++ b/tabled/src/settings/padding/mod.rs
@@ -132,7 +132,7 @@ impl<R, D> TableOption<R, ColoredConfig, D> for Padding {
 
 impl<R, D> TableOption<R, CompactConfig, D> for Padding {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
-        *cfg = cfg.set_padding(self.indent);
+        cfg.set_padding(self.indent);
     }
 }
 
diff --git a/tabled/src/settings/padding_color/mod.rs b/tabled/src/settings/padding_color/mod.rs
index dfae51f..cd68aba 100644
--- a/tabled/src/settings/padding_color/mod.rs
+++ b/tabled/src/settings/padding_color/mod.rs
@@ -142,7 +142,7 @@ where
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
         let c = self.colors.clone();
         let colors = Sides::new(c.left.into(), c.right.into(), c.top.into(), c.bottom.into());
-        *cfg = cfg.set_padding_color(colors);
+        cfg.set_padding_color(colors);
     }
 }
 
diff --git a/tabled/src/settings/padding_expand/mod.rs b/tabled/src/settings/padding_expand/mod.rs
index 7fb65e0..f2da461 100644
--- a/tabled/src/settings/padding_expand/mod.rs
+++ b/tabled/src/settings/padding_expand/mod.rs
@@ -110,7 +110,7 @@ where
     let count_cols = records.count_columns();
 
     for pos in entity.iter(count_rows, count_cols) {
-        let col = pos.1;
+        let col = pos.col();
         let column_width = widths[col];
         let width = records.get_width(pos);
 
@@ -141,7 +141,7 @@ where
     let count_cols = records.count_columns();
 
     for pos in entity.iter(count_rows, count_cols) {
-        let row = pos.0;
+        let row = pos.row();
         let row_height = heights[row];
         let cell_height = records.count_lines(pos);
 
diff --git a/tabled/src/settings/panel/horizontal_panel.rs b/tabled/src/settings/panel/horizontal_panel.rs
index 3593a95..5c45604 100644
--- a/tabled/src/settings/panel/horizontal_panel.rs
+++ b/tabled/src/settings/panel/horizontal_panel.rs
@@ -32,7 +32,7 @@ where
         }
 
         let is_intersect_vertical_span = (0..records.count_columns())
-            .any(|col| cfg.is_cell_covered_by_row_span((self.row, col)));
+            .any(|col| cfg.is_cell_covered_by_row_span((self.row, col).into()));
         if is_intersect_vertical_span {
             return;
         }
@@ -41,9 +41,9 @@ where
         move_row_spans(cfg, self.row);
 
         let text = self.text.as_ref().to_owned();
-        records.set((self.row, 0), text);
+        records.set((self.row, 0).into(), text);
 
-        cfg.set_column_span((self.row, 0), count_cols);
+        cfg.set_column_span((self.row, 0).into(), count_cols);
     }
 }
 
@@ -60,21 +60,21 @@ fn move_rows_aside<R: ExactRecords + Resizable>(records: &mut R, row: usize) {
 }
 
 fn move_row_spans(cfg: &mut SpannedConfig, target_row: usize) {
-    for ((row, col), span) in cfg.get_column_spans() {
-        if row < target_row {
+    for (p, span) in cfg.get_column_spans() {
+        if p.row() < target_row {
             continue;
         }
 
-        cfg.set_column_span((row, col), 1);
-        cfg.set_column_span((row + 1, col), span);
+        cfg.set_column_span(p, 1);
+        cfg.set_column_span(p + (1, 0), span);
     }
 
-    for ((row, col), span) in cfg.get_row_spans() {
-        if row < target_row {
+    for (p, span) in cfg.get_row_spans() {
+        if p.row() < target_row {
             continue;
         }
 
-        cfg.set_row_span((row, col), 1);
-        cfg.set_row_span((row + 1, col), span);
+        cfg.set_row_span(p, 1);
+        cfg.set_row_span(p + (1, 0), span);
     }
 }
diff --git a/tabled/src/settings/panel/vertical_panel.rs b/tabled/src/settings/panel/vertical_panel.rs
index b24459d..c3dbe35 100644
--- a/tabled/src/settings/panel/vertical_panel.rs
+++ b/tabled/src/settings/panel/vertical_panel.rs
@@ -52,7 +52,7 @@ where
         }
 
         let is_intersect_horizontal_span = (0..=records.count_rows())
-            .any(|row| cfg.is_cell_covered_by_column_span((row, self.col)));
+            .any(|row| cfg.is_cell_covered_by_column_span((row, self.col).into()));
 
         if is_intersect_horizontal_span {
             return;
@@ -62,9 +62,9 @@ where
         move_column_spans(cfg, self.col);
 
         let text = self.text.as_ref().to_owned();
-        records.set((0, self.col), text);
+        records.set((0, self.col).into(), text);
 
-        cfg.set_row_span((0, self.col), count_rows);
+        cfg.set_row_span((0, self.col).into(), count_rows);
     }
 }
 
@@ -80,22 +80,22 @@ fn move_columns_aside<R: Records + Resizable>(records: &mut R, column: usize) {
 }
 
 fn move_column_spans(cfg: &mut SpannedConfig, target_column: usize) {
-    for ((row, col), span) in cfg.get_column_spans() {
-        if col < target_column {
+    for (p, span) in cfg.get_column_spans() {
+        if p.col() < target_column {
             continue;
         }
 
-        cfg.set_column_span((row, col), 1);
-        cfg.set_column_span((row, col + 1), span);
+        cfg.set_column_span(p, 1);
+        cfg.set_column_span(p + (0, 1), span);
     }
 
-    for ((row, col), span) in cfg.get_row_spans() {
-        if col < target_column {
+    for (p, span) in cfg.get_row_spans() {
+        if p.col() < target_column {
             continue;
         }
 
-        cfg.set_row_span((row, col), 1);
-        cfg.set_row_span((row, col + 1), span);
+        cfg.set_row_span(p, 1);
+        cfg.set_row_span(p + (0, 1), span);
     }
 }
 
diff --git a/tabled/src/settings/rotate/mod.rs b/tabled/src/settings/rotate/mod.rs
index a87a167..408287f 100644
--- a/tabled/src/settings/rotate/mod.rs
+++ b/tabled/src/settings/rotate/mod.rs
@@ -86,7 +86,7 @@ where
     for row in 0..count_rows / 2 {
         for col in 0..count_cols {
             let last_row = count_rows - row - 1;
-            records.swap((last_row, col), (row, col));
+            records.swap((last_row, col).into(), (row, col).into());
         }
     }
 }
@@ -111,7 +111,7 @@ where
 
     for col in 0..size {
         for row in col..size {
-            records.swap((col, row), (row, col));
+            records.swap((col, row).into(), (row, col).into());
         }
     }
 
@@ -152,7 +152,7 @@ where
 
     for col in 0..size {
         for row in col..size {
-            records.swap((col, row), (row, col));
+            records.swap((col, row).into(), (row, col).into());
         }
     }
 
diff --git a/tabled/src/settings/span/column.rs b/tabled/src/settings/span/column.rs
index 50af64c..c658f68 100644
--- a/tabled/src/settings/span/column.rs
+++ b/tabled/src/settings/span/column.rs
@@ -39,13 +39,13 @@ where
 
 fn set_col_spans(cfg: &mut SpannedConfig, span: usize, entity: Entity, shape: (usize, usize)) {
     for pos in entity.iter(shape.0, shape.1) {
-        if !is_valid_pos(pos, shape) {
+        if !pos.is_covered(shape.into()) {
             continue;
         }
 
         let mut span = span;
-        if !is_column_span_valid(pos.1, span, shape.1) {
-            span = shape.1 - pos.1;
+        if !is_column_span_valid(pos.col(), span, shape.1) {
+            span = shape.1 - pos.col();
         }
 
         if span_has_intersections(cfg, pos, span) {
@@ -56,33 +56,32 @@ fn set_col_spans(cfg: &mut SpannedConfig, span: usize, entity: Entity, shape: (u
     }
 }
 
-fn set_span_column(cfg: &mut SpannedConfig, pos: (usize, usize), span: usize) {
+fn set_span_column(cfg: &mut SpannedConfig, p: Position, span: usize) {
     if span == 0 {
-        let (row, col) = pos;
-        if col == 0 {
+        if p.col() == 0 {
             return;
         }
 
-        if let Some(closecol) = closest_visible(cfg, (row, col - 1)) {
-            let span = col + 1 - closecol;
-            cfg.set_column_span((row, closecol), span);
+        if let Some(nearcol) = closest_visible(cfg, p - (0, 1)) {
+            let span = p.col() + 1 - nearcol;
+            cfg.set_column_span((p.row(), nearcol).into(), span);
         }
     }
 
-    cfg.set_column_span(pos, span);
+    cfg.set_column_span(p, span);
 }
 
 fn closest_visible(cfg: &SpannedConfig, mut pos: Position) -> Option<usize> {
     loop {
         if cfg.is_cell_visible(pos) {
-            return Some(pos.1);
+            return Some(pos.col());
         }
 
-        if pos.1 == 0 {
+        if pos.col() == 0 {
             return None;
         }
 
-        pos.1 -= 1;
+        pos -= (0, 1);
     }
 }
 
@@ -90,13 +89,9 @@ fn is_column_span_valid(col: usize, span: usize, count_cols: usize) -> bool {
     span + col <= count_cols
 }
 
-fn is_valid_pos((row, col): Position, (count_rows, count_cols): (usize, usize)) -> bool {
-    row < count_rows && col < count_cols
-}
-
-fn span_has_intersections(cfg: &SpannedConfig, (row, col): Position, span: usize) -> bool {
-    for col in col..col + span {
-        if !cfg.is_cell_visible((row, col)) {
+fn span_has_intersections(cfg: &SpannedConfig, p: Position, span: usize) -> bool {
+    for col in p.col()..p.col() + span {
+        if !cfg.is_cell_visible((p.row(), col).into()) {
             return true;
         }
     }
diff --git a/tabled/src/settings/span/row.rs b/tabled/src/settings/span/row.rs
index 68673f7..ffacf05 100644
--- a/tabled/src/settings/span/row.rs
+++ b/tabled/src/settings/span/row.rs
@@ -38,52 +38,51 @@ where
 }
 
 fn set_row_spans(cfg: &mut SpannedConfig, span: usize, entity: Entity, shape: (usize, usize)) {
-    for pos in entity.iter(shape.0, shape.1) {
-        if !is_valid_pos(pos, shape) {
+    for p in entity.iter(shape.0, shape.1) {
+        if !p.is_covered(shape.into()) {
             continue;
         }
 
         let mut span = span;
-        if !is_row_span_valid(pos.0, span, shape.0) {
-            span = shape.0 - pos.0;
+        if !is_row_span_valid(p.row(), span, shape.0) {
+            span = shape.0 - p.row();
         }
 
-        if span_has_intersections(cfg, pos, span) {
+        if span_has_intersections(cfg, p, span) {
             continue;
         }
 
-        set_span_row(cfg, pos, span);
+        set_span_row(cfg, p, span);
     }
 }
 
-fn set_span_row(cfg: &mut SpannedConfig, pos: (usize, usize), span: usize) {
+fn set_span_row(cfg: &mut SpannedConfig, p: Position, span: usize) {
     if span == 0 {
-        let (row, col) = pos;
-        if row == 0 {
+        if p.row() == 0 {
             return;
         }
 
-        if let Some(closerow) = closest_visible_row(cfg, (row - 1, col)) {
-            let span = row + 1 - closerow;
-            cfg.set_row_span((closerow, col), span);
+        if let Some(closerow) = closest_visible_row(cfg, p - (1, 0)) {
+            let span = p.row() + 1 - closerow;
+            cfg.set_row_span((closerow, p.col()).into(), span);
         }
     }
 
-    cfg.set_row_span(pos, span);
+    cfg.set_row_span(p, span);
 }
 
 fn closest_visible_row(cfg: &SpannedConfig, mut pos: Position) -> Option<usize> {
     loop {
         if cfg.is_cell_visible(pos) {
-            return Some(pos.0);
+            return Some(pos.row());
         }
 
-        if pos.0 == 0 {
+        if pos.row() == 0 {
             // can happen if we have a above horizontal spanned cell
             return None;
         }
 
-        pos.0 -= 1;
+        pos -= (1, 0);
     }
 }
 
@@ -91,13 +90,9 @@ fn is_row_span_valid(row: usize, span: usize, count_rows: usize) -> bool {
     span + row <= count_rows
 }
 
-fn is_valid_pos((row, col): Position, (count_rows, count_cols): (usize, usize)) -> bool {
-    row < count_rows && col < count_cols
-}
-
-fn span_has_intersections(cfg: &SpannedConfig, (row, col): Position, span: usize) -> bool {
-    for row in row..row + span {
-        if !cfg.is_cell_visible((row, col)) {
+fn span_has_intersections(cfg: &SpannedConfig, p: Position, span: usize) -> bool {
+    for row in p.row()..p.row() + span {
+        if !cfg.is_cell_visible((row, p.col()).into()) {
             return true;
         }
     }
diff --git a/tabled/src/settings/split/mod.rs b/tabled/src/settings/split/mod.rs
index 7e3fb3f..1c2de9b 100644
--- a/tabled/src/settings/split/mod.rs
+++ b/tabled/src/settings/split/mod.rs
@@ -528,8 +528,8 @@ fn compute_range_variables(
 /// utility for arguments of a position easily
 fn format_position(direction: Direction, primary_index: usize, secondary_index: usize) -> Position {
     match direction {
-        Direction::Column => (secondary_index, primary_index),
-        Direction::Row => (primary_index, secondary_index),
+        Direction::Column => (secondary_index, primary_index).into(),
+        Direction::Row => (primary_index, secondary_index).into(),
     }
 }
 
diff --git a/tabled/src/settings/style/border.rs b/tabled/src/settings/style/border.rs
index 912204e..0a14cac 100644
--- a/tabled/src/settings/style/border.rs
+++ b/tabled/src/settings/style/border.rs
@@ -290,13 +290,13 @@ where
         let border = self;
 
         for col in 0..count_columns {
-            let pos = (0, col);
+            let pos = (0, col).into();
             let mut b = cfg.get_border(pos, shape);
             b.top = border.top;
             b.right_top_corner = border.top;
             cfg.set_border(pos, b);
 
-            let pos = (count_rows - 1, col);
+            let pos = (count_rows - 1, col).into();
             let mut b = cfg.get_border(pos, shape);
             b.bottom = border.bottom;
             b.right_bottom_corner = border.bottom;
@@ -304,38 +304,38 @@ where
         }
 
         for row in 0..count_rows {
-            let pos = (row, 0);
+            let pos = (row, 0).into();
             let mut b = cfg.get_border(pos, shape);
             b.left = border.left;
             b.left_bottom_corner = border.left;
             cfg.set_border(pos, b);
 
-            let pos = (row, count_columns - 1);
+            let pos = (row, count_columns - 1).into();
             let mut b = cfg.get_border(pos, shape);
             b.right = border.right;
             b.right_bottom_corner = border.right;
             cfg.set_border(pos, b);
         }
 
-        let pos = (0, 0);
+        let pos = (0, 0).into();
         let mut b = cfg.get_border(pos, shape);
         b.left_top_corner = border.left_top_corner;
         cfg.remove_border(pos, shape);
         cfg.set_border(pos, b);
 
-        let pos = (0, count_columns - 1);
+        let pos = (0, count_columns - 1).into();
         let mut b = cfg.get_border(pos, shape);
         b.right_top_corner = border.right_top_corner;
         cfg.remove_border(pos, shape);
         cfg.set_border(pos, b);
 
-        let pos = (count_rows - 1, 0);
+        let pos = (count_rows - 1, 0).into();
         let mut b = cfg.get_border(pos, shape);
         b.left_bottom_corner = border.left_bottom_corner;
         cfg.remove_border(pos, shape);
         cfg.set_border(pos, b);
 
-        let pos = (count_rows - 1, count_columns - 1);
+        let pos = (count_rows - 1, count_columns - 1).into();
         let mut b = cfg.get_border(pos, shape);
         b.right_bottom_corner = border.right_bottom_corner;
         cfg.remove_border(pos, shape);
diff --git a/tabled/src/settings/style/border_color.rs b/tabled/src/settings/style/border_color.rs
index a029d4e..2d3f3c5 100644
--- a/tabled/src/settings/style/border_color.rs
+++ b/tabled/src/settings/style/border_color.rs
@@ -184,13 +184,13 @@ where
         let color = self.inner.clone().convert();
 
         for col in 0..count_columns {
-            let pos = (0, col);
+            let pos = (0, col).into();
             let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
             b.top = color.top.clone();
             b.right_top_corner = color.top.clone();
             cfg.set_border_color(pos, b);
 
-            let pos = (count_rows - 1, col);
+            let pos = (count_rows - 1, col).into();
             let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
             b.bottom = color.bottom.clone();
             b.right_bottom_corner = color.bottom.clone();
@@ -198,38 +198,38 @@ where
         }
 
         for row in 0..count_rows {
-            let pos = (row, 0);
+            let pos = (row, 0).into();
             let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
             b.left = color.left.clone();
             b.left_bottom_corner = color.left.clone();
             cfg.set_border_color(pos, b);
 
-            let pos = (row, count_columns - 1);
+            let pos = (row, count_columns - 1).into();
             let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
             b.right = color.right.clone();
             b.right_bottom_corner = color.right.clone();
             cfg.set_border_color(pos, b);
         }
 
-        let pos = (0, 0);
+        let pos = (0, 0).into();
         let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
         b.left_top_corner = color.left_top_corner.clone();
         cfg.remove_border_color(pos, shape);
         cfg.set_border_color(pos, b);
 
-        let pos = (0, count_columns - 1);
+        let pos = (0, count_columns - 1).into();
         let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
         b.right_top_corner = color.right_top_corner.clone();
         cfg.remove_border_color(pos, shape);
         cfg.set_border_color(pos, b);
 
-        let pos = (count_rows - 1, 0);
+        let pos = (count_rows - 1, 0).into();
         let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
         b.left_bottom_corner = color.left_bottom_corner.clone();
         cfg.remove_border_color(pos, shape);
         cfg.set_border_color(pos, b);
 
-        let pos = (count_rows - 1, count_columns - 1);
+        let pos = (count_rows - 1, count_columns - 1).into();
         let mut b = GridBorder::cloned(&cfg.get_border_color(pos, shape));
         b.right_bottom_corner = color.right_bottom_corner.clone();
         cfg.remove_border_color(pos, shape);
diff --git a/tabled/src/settings/style/builder.rs b/tabled/src/settings/style/builder.rs
index 3cb1df0..3be16e9 100644
--- a/tabled/src/settings/style/builder.rs
+++ b/tabled/src/settings/style/builder.rs
@@ -1453,7 +1453,7 @@ impl<T, B, L, R, H, V, Data, Dims, const HSIZE: usize, const VSIZE: usize>
     TableOption<Data, CompactConfig, Dims> for Style<T, B, L, R, H, V, HSIZE, VSIZE>
 {
     fn change(self, _: &mut Data, cfg: &mut CompactConfig, _: &mut Dims) {
-        *cfg = cfg.set_borders(self.borders);
+        cfg.set_borders(self.borders);
     }
 }
 
diff --git a/tabled/src/settings/style/line_text.rs b/tabled/src/settings/style/line_text.rs
index 862b0f3..2a256e0 100644
--- a/tabled/src/settings/style/line_text.rs
+++ b/tabled/src/settings/style/line_text.rs
@@ -216,14 +216,14 @@ fn set_horizontal_chars<D: Dimension>(
             None => return,
         };
 
-        let mut b = cfg.get_border((line, 0), shape);
+        let mut b = cfg.get_border((line, 0).into(), shape);
         b.left_top_corner = b.left_top_corner.map(|_| c);
-        cfg.set_border((line, 0), b);
+        cfg.set_border((line, 0).into(), b);
 
         if let Some(color) = color.as_ref() {
-            let mut b = cfg.get_border_color((line, 0), shape).cloned();
+            let mut b = cfg.get_border_color((line, 0).into(), shape).cloned();
             b.left_top_corner = Some(color.clone());
-            cfg.set_border_color((line, 0), b);
+            cfg.set_border_color((line, 0).into(), b);
         }
     }
 
@@ -240,10 +240,10 @@ fn set_horizontal_chars<D: Dimension>(
                     None => return,
                 };
 
-                cfg.set_horizontal_char((line, col), c, config::Offset::Begin(off));
+                cfg.set_horizontal_char((line, col).into(), c, config::Offset::Begin(off));
                 if let Some(color) = color.as_ref() {
                     cfg.set_horizontal_color(
-                        (line, col),
+                        (line, col).into(),
                         color.clone(),
                         config::Offset::Begin(off),
                     );
@@ -262,14 +262,14 @@ fn set_horizontal_chars<D: Dimension>(
                     None => return,
                 };
 
-                let mut b = cfg.get_border((line, col), shape);
+                let mut b = cfg.get_border((line, col).into(), shape);
                 b.right_top_corner = b.right_top_corner.map(|_| c);
-                cfg.set_border((line, col), b);
+                cfg.set_border((line, col).into(), b);
 
                 if let Some(color) = color.as_ref() {
-                    let mut b = cfg.get_border_color((line, col), shape).cloned();
+                    let mut b = cfg.get_border_color((line, col).into(), shape).cloned();
                     b.right_top_corner = Some(color.clone());
-                    cfg.set_border_color((line, col), b);
+                    cfg.set_border_color((line, col).into(), b);
                 }
             }
         }
@@ -304,14 +304,14 @@ fn set_vertical_chars<D>(
             None => return,
         };
 
-        let mut b = cfg.get_border((0, line), shape);
+        let mut b = cfg.get_border((0, line).into(), shape);
         b.left_top_corner = b.left_top_corner.map(|_| c);
-        cfg.set_border((0, line), b);
+        cfg.set_border((0, line).into(), b);
 
         if let Some(color) = color.as_ref() {
-            let mut b = cfg.get_border_color((0, line), shape).cloned();
+            let mut b = cfg.get_border_color((0, line).into(), shape).cloned();
             b.left_top_corner = Some(color.clone());
-            cfg.set_border_color((0, line), b);
+            cfg.set_border_color((0, line).into(), b);
         }
     }
 
@@ -328,10 +328,14 @@ fn set_vertical_chars<D>(
                     None => return,
                 };
 
-                cfg.set_vertical_char((row, line), c, config::Offset::Begin(off)); // todo: is this correct? I think it shall be off + i
+                cfg.set_vertical_char((row, line).into(), c, config::Offset::Begin(off)); // todo: is this correct? I think it shall be off + i
 
                 if let Some(color) = color.as_ref() {
-                    cfg.set_vertical_color((row, line), color.clone(), config::Offset::Begin(off));
+                    cfg.set_vertical_color(
+                        (row, line).into(),
+                        color.clone(),
+                        config::Offset::Begin(off),
+                    );
                 }
             }
         }
@@ -347,14 +351,14 @@ fn set_vertical_chars<D>(
                     None => return,
                 };
 
-                let mut b = cfg.get_border((row, line), shape);
+                let mut b = cfg.get_border((row, line).into(), shape);
                 b.left_bottom_corner = b.left_bottom_corner.map(|_| c);
-                cfg.set_border((row, line), b);
+                cfg.set_border((row, line).into(), b);
 
                 if let Some(color) = color.as_ref() {
-                    let mut b = cfg.get_border_color((row, line), shape).cloned();
+                    let mut b = cfg.get_border_color((row, line).into(), shape).cloned();
                     b.left_bottom_corner = Some(color.clone());
-                    cfg.set_border_color((row, line), b);
+                    cfg.set_border_color((row, line).into(), b);
                 }
             }
         }
diff --git a/tabled/src/settings/style/mod.rs b/tabled/src/settings/style/mod.rs
index 39284ea..7029165 100644
--- a/tabled/src/settings/style/mod.rs
+++ b/tabled/src/settings/style/mod.rs
@@ -142,7 +142,7 @@ impl<R, D> TableOption<R, ColoredConfig, D> for Borders<char> {
 
 impl<R, D> TableOption<R, CompactConfig, D> for Borders<char> {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
-        *cfg = cfg.set_borders(self);
+        cfg.set_borders(self);
     }
 }
 
diff --git a/tabled/src/settings/style/span_border_correction.rs b/tabled/src/settings/style/span_border_correction.rs
index b6a07c4..7ca468d 100644
--- a/tabled/src/settings/style/span_border_correction.rs
+++ b/tabled/src/settings/style/span_border_correction.rs
@@ -87,19 +87,19 @@ where
 }
 
 fn correct_span_styles(cfg: &mut SpannedConfig, shape: (usize, usize)) {
-    for ((row, c), span) in cfg.get_column_spans() {
-        for col in c..c + span {
+    for (p, span) in cfg.get_column_spans() {
+        for col in p.col()..p.col() + span {
             if col == 0 {
                 continue;
             }
 
-            let is_first = col == c;
-            let has_up = row > 0 && has_left(cfg, (row - 1, col), shape);
-            let has_down = row + 1 < shape.0 && has_left(cfg, (row + 1, col), shape);
+            let is_first = col == p.col();
+            let has_up = p.row() > 0 && has_left(cfg, (p.row() - 1, col).into(), shape);
+            let has_down = p.row() + 1 < shape.0 && has_left(cfg, (p.row() + 1, col).into(), shape);
 
             let borders = cfg.get_borders();
 
-            let mut border = cfg.get_border((row, col), shape);
+            let mut border = cfg.get_border((p.row(), col).into(), shape);
 
             let has_top_border = border.left_top_corner.is_some() && border.top.is_some();
             if has_top_border {
@@ -127,18 +127,20 @@ fn correct_span_styles(cfg: &mut SpannedConfig, shape: (usize, usize)) {
                 }
             }
 
-            cfg.set_border((row, col), border);
+            cfg.set_border((p.row(), col).into(), border);
         }
     }
 
-    for ((r, col), span) in cfg.get_row_spans() {
+    for (p, span) in cfg.get_row_spans() {
+        let (r, col) = p.into();
+
         for row in r + 1..r + span {
-            let mut border = cfg.get_border((row, col), shape);
+            let mut border = cfg.get_border((row, col).into(), shape);
             let borders = cfg.get_borders();
 
             let has_left_border = border.left_top_corner.is_some();
             if has_left_border {
-                let has_left = col > 0 && has_top(cfg, (row, col - 1), shape);
+                let has_left = col > 0 && has_top(cfg, (row, col - 1).into(), shape);
                 if has_left {
                     border.left_top_corner = borders.right_intersection;
                 } else {
@@ -148,7 +150,7 @@ fn correct_span_styles(cfg: &mut SpannedConfig, shape: (usize, usize)) {
 
             let has_right_border = border.right_top_corner.is_some();
             if has_right_border {
-                let has_right = col + 1 < shape.1 && has_top(cfg, (row, col + 1), shape);
+                let has_right = col + 1 < shape.1 && has_top(cfg, (row, col + 1).into(), shape);
                 if has_right {
                     border.right_top_corner = borders.left_intersection;
                 } else {
@@ -156,21 +158,23 @@ fn correct_span_styles(cfg: &mut SpannedConfig, shape: (usize, usize)) {
                 }
             }
 
-            cfg.set_border((row, col), border);
+            cfg.set_border((row, col).into(), border);
         }
     }
 
     let cells = iter_totally_spanned_cells(cfg, shape).collect::<Vec<_>>();
-    for (row, col) in cells {
+    for p in cells {
+        let (row, col) = p.into();
+
         if row == 0 {
             continue;
         }
 
-        let mut border = cfg.get_border((row, col), shape);
+        let mut border = cfg.get_border((row, col).into(), shape);
         let borders = cfg.get_borders();
 
-        let has_right = col + 1 < shape.1 && has_top(cfg, (row, col + 1), shape);
-        let has_up = has_left(cfg, (row - 1, col), shape);
+        let has_right = col + 1 < shape.1 && has_top(cfg, (row, col + 1).into(), shape);
+        let has_up = has_left(cfg, (row - 1, col).into(), shape);
 
         if has_up && !has_right {
             border.right_top_corner = borders.right_intersection;
@@ -180,12 +184,12 @@ fn correct_span_styles(cfg: &mut SpannedConfig, shape: (usize, usize)) {
             border.right_top_corner = borders.left_intersection;
         }
 
-        let has_down = row + 1 < shape.0 && has_left(cfg, (row + 1, col), shape);
+        let has_down = row + 1 < shape.0 && has_left(cfg, (row + 1, col).into(), shape);
         if has_down {
             border.left_bottom_corner = borders.top_intersection;
         }
 
-        cfg.set_border((row, col), border);
+        cfg.set_border((row, col).into(), border);
     }
 }
 
@@ -215,7 +219,7 @@ fn iter_totally_spanned_cells(
     let (count_rows, count_cols) = shape;
     (0..count_rows).flat_map(move |row| {
         (0..count_cols)
-            .map(move |col| (row, col))
-            .filter(move |&p| cfg.is_cell_covered_by_both_spans(p))
+            .map(move |col| (row, col).into())
+            .filter(move |p| cfg.is_cell_covered_by_both_spans(*p))
     })
 }
diff --git a/tabled/src/settings/themes/column_names.rs b/tabled/src/settings/themes/column_names.rs
index b32ba22..1e8d8bf 100644
--- a/tabled/src/settings/themes/column_names.rs
+++ b/tabled/src/settings/themes/column_names.rs
@@ -287,7 +287,7 @@ fn set_column_text(
     for (column, (width, name)) in widths.into_iter().zip(names).enumerate() {
         let color = get_color(&colors, column);
         let alignment = alignments.get(column).unwrap_or(AlignmentHorizontal::Left);
-        let left_vertical = get_vertical_width(cfg, (target_line, column), count_columns);
+        let left_vertical = get_vertical_width(cfg, (target_line, column).into(), count_columns);
         let grid_offset =
             total_width + left_vertical + get_horizontal_indent(&name, alignment, width);
         let line = Row::from(target_line);
@@ -323,7 +323,7 @@ fn set_row_text(
     for (row, (row_height, name)) in heights.into_iter().zip(names).enumerate() {
         let color = get_color(&colors, row);
         let alignment = alignments.get(row).unwrap_or(AlignmentVertical::Top);
-        let top_horizontal = get_horizontal_width(cfg, (row, target_line), count_rows);
+        let top_horizontal = get_horizontal_width(cfg, (row, target_line).into(), count_rows);
         let cell_indent = get_vertical_indent(&name, alignment, row_height);
         let grid_offset = total_height + top_horizontal + cell_indent;
         let line = Column::from(target_line);
@@ -369,7 +369,7 @@ fn collect_head(records: &mut VecRecords<Text<String>>) -> Vec<String> {
     }
 
     let names = (0..records.count_columns())
-        .map(|column| records.get_line((0, column), 0))
+        .map(|column| records.get_line((0, column).into(), 0))
         .map(ToString::to_string)
         .collect();
 
diff --git a/tabled/src/settings/themes/layout.rs b/tabled/src/settings/themes/layout.rs
index 9537f62..1e07d59 100644
--- a/tabled/src/settings/themes/layout.rs
+++ b/tabled/src/settings/themes/layout.rs
@@ -94,7 +94,7 @@ where
     records.insert_row(pos);
 
     for (col, text) in row.into_iter().enumerate() {
-        records.set((pos, col), text);
+        records.set((pos, col).into(), text);
     }
 }
 
@@ -105,7 +105,7 @@ where
     records.insert_column(pos);
 
     for (row, text) in column.into_iter().enumerate() {
-        records.set((row, pos), text);
+        records.set((row, pos).into(), text);
     }
 }
 
@@ -135,7 +135,7 @@ where
     R: Records + PeekableRecords,
 {
     (0..records.count_columns())
-        .map(|column| records.get_text((row, column)))
+        .map(|column| records.get_text((row, column).into()))
         .map(ToString::to_string)
         .collect()
 }
@@ -145,7 +145,7 @@ where
     R: Records + PeekableRecords + ExactRecords,
 {
     (0..records.count_rows())
-        .map(|row| records.get_text((row, column)))
+        .map(|row| records.get_text((row, column).into()))
         .map(ToString::to_string)
         .collect()
 }
@@ -159,6 +159,6 @@ where
     let last_row = records.count_rows() - 1;
 
     for (col, text) in row.into_iter().enumerate() {
-        records.set((last_row, col), text);
+        records.set((last_row, col).into(), text);
     }
 }
diff --git a/tabled/src/settings/themes/theme.rs b/tabled/src/settings/themes/theme.rs
index a59492c..00fda71 100644
--- a/tabled/src/settings/themes/theme.rs
+++ b/tabled/src/settings/themes/theme.rs
@@ -371,7 +371,7 @@ impl<R, D> TableOption<R, ColoredConfig, D> for Theme {
 
 impl<R, D> TableOption<R, CompactConfig, D> for Theme {
     fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
-        *cfg = cfg.set_borders(self.chars);
+        cfg.set_borders(self.chars);
     }
 }
 
diff --git a/tabled/src/settings/width/min_width.rs b/tabled/src/settings/width/min_width.rs
index 13dc147..e26ce3f 100644
--- a/tabled/src/settings/width/min_width.rs
+++ b/tabled/src/settings/width/min_width.rs
@@ -113,8 +113,7 @@ where
         let count_columns = records.count_columns();
 
         for pos in entity.iter(count_rows, count_columns) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_columns;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_columns).into()) {
                 continue;
             }
 
diff --git a/tabled/src/settings/width/truncate.rs b/tabled/src/settings/width/truncate.rs
index b15d492..ddba22c 100644
--- a/tabled/src/settings/width/truncate.rs
+++ b/tabled/src/settings/width/truncate.rs
@@ -209,8 +209,7 @@ where
         let colorize = need_suffix_color_preservation(&self.suffix);
 
         for pos in entity.iter(count_rows, count_columns) {
-            let is_valid_pos = pos.0 < count_rows && pos.1 < count_columns;
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_columns).into()) {
                 continue;
             }
 
@@ -443,9 +442,9 @@ fn get_decrease_cell_list(
     let mut points = Vec::new();
     (0..shape.1).for_each(|col| {
         (0..shape.0)
-            .filter(|&row| cfg.is_cell_visible((row, col)))
+            .filter(|&row| cfg.is_cell_visible((row, col).into()))
             .for_each(|row| {
-                let (width, width_min) = match cfg.get_column_span((row, col)) {
+                let (width, width_min) = match cfg.get_column_span((row, col).into()) {
                     Some(span) => {
                         let width = (col..col + span).map(|i| widths[i]).sum::<usize>();
                         let min_width = (col..col + span).map(|i| min_widths[i]).sum::<usize>();
@@ -456,7 +455,7 @@ fn get_decrease_cell_list(
                 };
 
                 if width >= width_min {
-                    let padding = cfg.get_padding((row, col));
+                    let padding = cfg.get_padding((row, col).into());
                     let width = width.saturating_sub(padding.left.size + padding.right.size);
 
                     points.push(((row, col), width));
diff --git a/tabled/src/settings/width/wrap.rs b/tabled/src/settings/width/wrap.rs
index 36ea5ea..b4920ba 100644
--- a/tabled/src/settings/width/wrap.rs
+++ b/tabled/src/settings/width/wrap.rs
@@ -148,8 +148,7 @@ where
         let count_columns = records.count_columns();
 
         for pos in entity.iter(count_rows, count_columns) {
-            let is_valid_pos = pos.0 < records.count_rows() && pos.1 < records.count_columns();
-            if !is_valid_pos {
+            if !pos.is_covered((count_rows, count_columns).into()) {
                 continue;
             }
 
@@ -858,9 +857,9 @@ fn get_decrease_cell_list(
     let mut points = Vec::new();
     (0..shape.1).for_each(|col| {
         (0..shape.0)
-            .filter(|&row| cfg.is_cell_visible((row, col)))
+            .filter(|&row| cfg.is_cell_visible((row, col).into()))
             .for_each(|row| {
-                let (width, width_min) = match cfg.get_column_span((row, col)) {
+                let (width, width_min) = match cfg.get_column_span((row, col).into()) {
                     Some(span) => {
                         let width = (col..col + span).map(|i| widths[i]).sum::<usize>();
                         let min_width = (col..col + span).map(|i| min_widths[i]).sum::<usize>();
@@ -871,7 +870,7 @@ fn get_decrease_cell_list(
                 };
 
                 if width >= width_min {
-                    let padding = cfg.get_padding((row, col));
+                    let padding = cfg.get_padding((row, col).into());
                     let width = width.saturating_sub(padding.left.size + padding.right.size);
 
                     points.push(((row, col), width));
diff --git a/tabled/src/tables/compact.rs b/tabled/src/tables/compact.rs
index d1e7487..d0a9c45 100644
--- a/tabled/src/tables/compact.rs
+++ b/tabled/src/tables/compact.rs
@@ -301,15 +301,16 @@ where
 }
 
 const fn create_config() -> CompactConfig {
-    CompactConfig::new()
-        .set_padding(Sides::new(
-            Indent::spaced(1),
-            Indent::spaced(1),
-            Indent::zero(),
-            Indent::zero(),
-        ))
-        .set_alignment_horizontal(AlignmentHorizontal::Left)
-        .set_borders(Style::ascii().get_borders())
+    let mut cfg = CompactConfig::new();
+    cfg.set_padding(Sides::new(
+        Indent::spaced(1),
+        Indent::spaced(1),
+        Indent::zero(),
+        Indent::zero(),
+    ));
+    cfg.set_alignment_horizontal(AlignmentHorizontal::Left);
+    cfg.set_borders(Style::ascii().get_borders());
+    cfg
 }
 
 impl<R, D> TableOption<R, CompactConfig, D> for CompactConfig {
diff --git a/tabled/src/tables/iter.rs b/tabled/src/tables/iter.rs
index ee0320c..1750e6d 100644
--- a/tabled/src/tables/iter.rs
+++ b/tabled/src/tables/iter.rs
@@ -349,16 +349,17 @@ fn get_count_columns<T>(opts: &Settings, buf: &[Vec<T>]) -> usize {
     }
 }
 
-fn create_config() -> CompactConfig {
-    CompactConfig::default()
-        .set_padding(Sides::new(
-            Indent::spaced(1),
-            Indent::spaced(1),
-            Indent::default(),
-            Indent::default(),
-        ))
-        .set_alignment_horizontal(AlignmentHorizontal::Left)
-        .set_borders(Style::ascii().get_borders())
+const fn create_config() -> CompactConfig {
+    let mut cfg = CompactConfig::new();
+    cfg.set_padding(Sides::new(
+        Indent::spaced(1),
+        Indent::spaced(1),
+        Indent::zero(),
+        Indent::zero(),
+    ));
+    cfg.set_alignment_horizontal(AlignmentHorizontal::Left);
+    cfg.set_borders(Style::ascii().get_borders());
+    cfg
 }
 
 fn build_records<I>(
diff --git a/tabled/src/tables/table_pool.rs b/tabled/src/tables/table_pool.rs
index ad429da..251a497 100644
--- a/tabled/src/tables/table_pool.rs
+++ b/tabled/src/tables/table_pool.rs
@@ -244,16 +244,15 @@ mod print {
         grid::{
             ansi::ANSIStr,
             config::{
-                AlignmentHorizontal, AlignmentVertical, Border, Borders, ColoredConfig,
-                CompactMultilineConfig, Indent, Offset, Sides,
+                AlignmentHorizontal, AlignmentVertical, Border, Borders, CompactMultilineConfig,
+                Indent, Sides,
             },
-            dimension::{Dimension, DimensionPriority, Estimate, PoolTableDimension},
-            records::Records,
+            dimension::{DimensionPriority, PoolTableDimension},
             util::string::{
                 count_lines, get_line_width, get_lines, get_text_dimension, get_text_width,
             },
         },
-        settings::{Padding, Style, TableOption},
+        settings::{Padding, Style},
     };
 
     use super::TableValue;
@@ -983,104 +982,6 @@ mod print {
         }
     }
 
-    #[allow(dead_code)]
-    struct ConfigCell(PrintContext);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for ConfigCell {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            {
-                // we set a horizontal lines to borders to not complicate logic with cleaning it
-
-                let mut borders = *cfg.get_borders();
-                if let Some(line) = cfg.get_horizontal_line(0) {
-                    borders.top = line.main;
-                    borders.top_left = line.left;
-                    borders.top_right = line.right;
-                }
-
-                if let Some(line) = cfg.get_horizontal_line(1) {
-                    borders.bottom = line.main;
-                    borders.bottom_left = line.left;
-                    borders.bottom_right = line.right;
-                }
-
-                cfg_clear_borders(cfg);
-                cfg.set_borders(borders);
-            }
-
-            let mut ctx = self.0;
-
-            let has_vertical = cfg.get_borders().has_left();
-            if !ctx.intersections_horizontal.is_empty() && has_vertical {
-                let mut splits = short_splits(&mut ctx.intersections_horizontal, ctx.size.width);
-                squash_splits(&mut splits);
-
-                let c = cfg.get_borders().bottom_intersection.unwrap_or(' ');
-                cfg_set_top_chars(cfg, &splits, c)
-            }
-
-            let has_horizontal = cfg.get_borders().has_top();
-            if !ctx.intersections_vertical.is_empty() && has_horizontal {
-                let mut splits = short_splits(&mut ctx.intersections_vertical, ctx.size.height);
-                squash_splits(&mut splits);
-
-                let c = cfg.get_borders().right_intersection.unwrap_or(' ');
-                cfg_set_left_chars(cfg, &splits, c)
-            }
-
-            let mut borders = *cfg.get_borders();
-
-            // set top_left
-            {
-                if ctx.kv && ctx.kv_is_first {
-                    borders.top_left = borders.top_intersection;
-                }
-
-                if ctx.kv && !ctx.kv_is_first {
-                    borders.top_left = borders.intersection;
-                }
-
-                if ctx.kv && ctx.list && !ctx.list_is_first {
-                    borders.top_left = borders.left_intersection;
-                }
-
-                if ctx.is_first_col && !ctx.is_first_row {
-                    borders.top_left = borders.left_intersection;
-                }
-
-                if ctx.lean_top {
-                    borders.top_left = borders.top_intersection;
-                }
-
-                if ctx.top_left {
-                    borders.top_left = borders.left_intersection;
-                }
-
-                if ctx.top_intersection {
-                    borders.top_left = borders.intersection;
-                }
-            }
-
-            if ctx.is_last_col && !ctx.is_first_row {
-                borders.top_right = borders.right_intersection;
-            }
-
-            if !ctx.is_first_col && ctx.is_last_row {
-                borders.bottom_left = borders.bottom_intersection;
-            }
-
-            if !ctx.is_last_row || ctx.no_bottom {
-                cfg_no_bottom_borders(&mut borders);
-            }
-
-            if ctx.no_right {
-                cfg_no_right_borders(&mut borders);
-            }
-
-            cfg.set_borders(borders);
-        }
-    }
-
     fn cfg_no_bottom_borders(borders: &mut Borders<char>) {
         borders.bottom = None;
         borders.bottom_intersection = None;
@@ -1097,248 +998,6 @@ mod print {
         borders.vertical = None;
     }
 
-    #[allow(dead_code)]
-    fn cfg_set_top_chars(cfg: &mut ColoredConfig, list: &[usize], c: char) {
-        for &split in list {
-            let offset = split;
-            cfg.set_horizontal_char((0, 0), c, Offset::Begin(offset));
-        }
-    }
-
-    #[allow(dead_code)]
-    fn cfg_set_left_chars(cfg: &mut ColoredConfig, list: &[usize], c: char) {
-        for &offset in list {
-            cfg.set_vertical_char((0, 0), c, Offset::Begin(offset));
-        }
-    }
-
-    #[allow(dead_code)]
-    struct NoTopBorders;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for NoTopBorders {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top = None;
-            borders.top_intersection = None;
-            borders.top_left = None;
-            borders.top_right = None;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct NoBottomBorders;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for NoBottomBorders {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.bottom = None;
-            borders.bottom_intersection = None;
-            borders.bottom_left = None;
-            borders.bottom_right = None;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct NoRightBorders;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for NoRightBorders {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_right = None;
-            borders.bottom_right = None;
-            borders.right = None;
-            borders.right_intersection = None;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct NoLeftBorders;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for NoLeftBorders {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_left = None;
-            borders.bottom_left = None;
-            borders.left = None;
-            borders.left_intersection = None;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct TopLeftChangeTopIntersection;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for TopLeftChangeTopIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_left = borders.top_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct TopLeftChangeIntersection;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for TopLeftChangeIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_left = borders.intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct TopLeftChangeToLeft;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for TopLeftChangeToLeft {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_left = borders.left_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct TopRightChangeToRight;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for TopRightChangeToRight {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.top_right = borders.right_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct BottomLeftChangeSplit;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeSplit {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.bottom_left = borders.left_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct BottomLeftChangeSplitToIntersection;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeSplitToIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.bottom_left = borders.intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct BottomRightChangeToRight;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for BottomRightChangeToRight {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.bottom_right = borders.right_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct BottomLeftChangeToBottomIntersection;
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for BottomLeftChangeToBottomIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            let mut borders = *cfg.get_borders();
-            borders.bottom_left = borders.bottom_intersection;
-
-            cfg.set_borders(borders);
-        }
-    }
-
-    #[allow(dead_code)]
-    struct SetBottomChars<'a>(&'a [usize], char);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for SetBottomChars<'_>
-    where
-        R: Records,
-        for<'a> &'a R: Records,
-        for<'a> D: Dimension + Estimate<&'a R, ColoredConfig>,
-    {
-        fn change(self, records: &mut R, cfg: &mut ColoredConfig, dims: &mut D) {
-            dims.estimate(&*records, cfg);
-
-            let table_width = (0..records.count_columns())
-                .map(|col| dims.get_width(col))
-                .sum::<usize>()
-                + cfg.count_vertical(records.count_columns());
-            let mut current_width = 0;
-
-            for pos in self.0 {
-                current_width += pos;
-                if current_width > table_width {
-                    break;
-                }
-
-                let split_char = self.1;
-                cfg.set_horizontal_char((1, 0), split_char, Offset::Begin(current_width));
-
-                current_width += 1;
-            }
-        }
-    }
-
-    #[allow(dead_code)]
-    struct SetTopChars<'a>(&'a [usize], char);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for SetTopChars<'_> {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            for &split in self.0 {
-                let offset = split;
-                cfg.set_horizontal_char((0, 0), self.1, Offset::Begin(offset));
-            }
-        }
-    }
-
-    #[allow(dead_code)]
-    struct SetLeftChars<'a>(&'a [usize], char);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for SetLeftChars<'_> {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            for &offset in self.0 {
-                cfg.set_vertical_char((0, 0), self.1, Offset::Begin(offset));
-            }
-        }
-    }
-
-    struct GetTopIntersection(char);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for &mut GetTopIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            self.0 = cfg.get_borders().top_intersection.unwrap_or(' ');
-        }
-    }
-
-    struct GetBottomIntersection(char);
-
-    impl<R, D> TableOption<R, ColoredConfig, D> for &mut GetBottomIntersection {
-        fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-            self.0 = cfg.get_borders().bottom_intersection.unwrap_or(' ');
-        }
-    }
-
     #[derive(Debug, Default)]
     struct Dimensions {
         all: HashMap<usize, Dim>,
@@ -1630,14 +1289,4 @@ mod print {
             (!pad_color.bottom.is_empty()).then_some(pad_color.bottom),
         )
     }
-
-    #[allow(dead_code)]
-    fn cfg_clear_borders(cfg: &mut ColoredConfig) {
-        cfg.remove_borders();
-        cfg.remove_borders_colors();
-        cfg.remove_vertical_chars();
-        cfg.remove_horizontal_chars();
-        cfg.remove_color_line_horizontal();
-        cfg.remove_color_line_vertical();
-    }
 }


Test patch:
diff --git a/papergrid/tests/grid/column_span.rs b/papergrid/tests/grid/column_span.rs
index 3ea8f85..9a0a217 100644
--- a/papergrid/tests/grid/column_span.rs
+++ b/papergrid/tests/grid/column_span.rs
@@ -1,6 +1,6 @@
 #![cfg(feature = "std")]
 
-use papergrid::config::{AlignmentHorizontal, Borders, Entity, Indent, Sides};
+use papergrid::config::{pos, AlignmentHorizontal, Borders, Entity, Indent, Sides};
 
 use crate::util::grid;
 use testing_table::test_table;
@@ -9,7 +9,7 @@ test_table!(
     row_span,
     grid(2, 2)
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
             cfg.set_alignment_horizontal(Entity::Cell(0, 0), AlignmentHorizontal::Center);
         })
         .build(),
@@ -23,9 +23,9 @@ test_table!(
 test_table!(
     miltiline_span,
     grid(2, 2)
-        .change_cell((0, 0), "0-0\n0-1")
+        .change_cell(pos(0, 0), "0-0\n0-1")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
             cfg.set_alignment_horizontal(Entity::Cell(0, 0), AlignmentHorizontal::Center);
         })
         .build(),
@@ -47,8 +47,8 @@ test_table!(
             ["full last line", "", ""],
         ])
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((3, 0), 3);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(3, 0), 3);
         })
         .build(),
     "+-----+----+----+"
@@ -66,7 +66,7 @@ test_table!(
     row_span_with_horizontal_ident,
     grid(3, 2)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
             cfg.set_padding(
                 Entity::Cell(1, 0),
                 Sides::new(
@@ -91,9 +91,9 @@ test_table!(
     _row_span_3x3_with_horizontal_ident,
     grid(3, 3)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 3);
-            cfg.set_column_span((1, 0), 2);
-            cfg.set_column_span((2, 0), 2);
+            cfg.set_column_span(pos(0, 0), 3);
+            cfg.set_column_span(pos(1, 0), 2);
+            cfg.set_column_span(pos(2, 0), 2);
         })
         .build(),
     "+-+-+---+"
@@ -108,10 +108,10 @@ test_table!(
 test_table!(
     _3x3_with_2_colided_row_span_0,
     grid(3, 3)
-        .change_cell((0, 0), "0-0xxxxxxx")
+        .change_cell(pos(0, 0), "0-0xxxxxxx")
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 1), 2);
         })
         .build(),
     "+-----+----+---+"
@@ -126,10 +126,10 @@ test_table!(
 test_table!(
     _3x3_with_2_colided_row_span_1,
     grid(3, 3)
-        .change_cell((1, 1), "1-1xxxxxxx")
+        .change_cell(pos(1, 1), "1-1xxxxxxx")
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 1), 2);
         })
         .build(),
     "+---+-----+----+"
@@ -144,11 +144,11 @@ test_table!(
 test_table!(
     _3x3_with_2_colided_row_span_2,
     grid(3, 3)
-        .change_cell((1, 1), "1-1xxxxxxx")
-        .change_cell((2, 0), "2-0xxxxxxxxxxxxx")
+        .change_cell(pos(1, 1), "1-1xxxxxxx")
+        .change_cell(pos(2, 0), "2-0xxxxxxxxxxxxx")
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 1), 2);
         })
         .build(),
     "+----------------+-----+----+"
@@ -163,10 +163,10 @@ test_table!(
 test_table!(
     _3x3_with_2_colided_row_span_3,
     grid(3, 3)
-        .change_cell((2, 1), "2-1xxxxxxxxxxxxx")
+        .change_cell(pos(2, 1), "2-1xxxxxxxxxxxxx")
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 1), 2);
         })
         .build(),
     "+---+----------------+---+"
@@ -181,10 +181,10 @@ test_table!(
 test_table!(
     _3x3_with_2_colided_row_span_4,
     grid(3, 3)
-        .change_cell((0, 2), "0-2xxxxxxxxxxxxx")
+        .change_cell(pos(0, 2), "0-2xxxxxxxxxxxxx")
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 1), 2);
         })
         .build(),
     "+---+---+----------------+"
@@ -199,8 +199,8 @@ test_table!(
 test_table!(
     spaned_column_in_first_cell_3x3,
     grid(3, 3)
-        .change_cell((0, 0), "0-0xxxxxxx")
-        .config(|cfg| cfg.set_column_span((0, 0), 2))
+        .change_cell(pos(0, 0), "0-0xxxxxxx")
+        .config(|cfg| cfg.set_column_span(pos(0, 0), 2))
         .build(),
     "+-----+----+---+"
     "|0-0xxxxxxx|0-2|"
@@ -216,8 +216,8 @@ test_table!(
     grid(3, 2)
         .data([["first row", ""], ["0", "1"], ["a longer second row", ""]])
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((2, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(2, 0), 2);
         })
         .build(),
     "+---------+---------+"
@@ -233,7 +233,7 @@ test_table!(
     row_span_with_odd_length,
     grid(2, 2)
         .data([["3   ", ""], ["2", "4"]])
-        .config(|cfg| cfg.set_column_span((0, 0), 2))
+        .config(|cfg| cfg.set_column_span(pos(0, 0), 2))
         .build(),
     "+--+-+"
     "|3   |"
@@ -246,9 +246,9 @@ test_table!(
     only_row_spaned,
     grid(3, 2)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
-            cfg.set_column_span((2, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
+            cfg.set_column_span(pos(2, 0), 2);
         })
         .build(),
     "+-+-+"
@@ -264,7 +264,7 @@ test_table!(
     grid_2x2_span_test,
     grid(2, 2)
         .data([["123", ""], ["asd", "asd"]])
-        .config(|cfg| cfg.set_column_span((0, 0), 2))
+        .config(|cfg| cfg.set_column_span(pos(0, 0), 2))
         .build(),
     "+---+---+"
     "|123    |"
@@ -278,8 +278,8 @@ test_table!(
     grid(2, 2)
         .data([["1234", ""], ["asdw", ""]])
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
         })
         .build(),
     "+--+-+"
@@ -294,8 +294,8 @@ test_table!(
     grid(2, 2)
         .data([["1", ""], ["a", ""]])
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
         })
         .build(),
     "+++"
@@ -310,7 +310,7 @@ test_table!(
     grid(2, 2)
         .config(|cfg| {
             cfg.set_borders(Borders::default());
-            cfg.set_column_span((0, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
             cfg.set_alignment_horizontal(Entity::Cell(0, 0), AlignmentHorizontal::Center);
         })
         .build(),
@@ -321,7 +321,7 @@ test_table!(
 test_table!(
     _2x3_zero_span_between_cells_0,
     grid(2, 3)
-        .config(|cfg| cfg.set_column_span((0, 0), 2))
+        .config(|cfg| cfg.set_column_span(pos(0, 0), 2))
         .build(),
     "+---+---+---+"
     "|0-0    |0-2|"
@@ -334,8 +334,8 @@ test_table!(
     _2x3_zero_span_between_cells_1,
     grid(2, 3)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
         })
         .build(),
     "+-+-+---+"
@@ -349,7 +349,7 @@ test_table!(
     _2x3_zero_span_at_the_end_0,
     grid(2, 3)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 3);
+            cfg.set_column_span(pos(0, 0), 3);
         })
         .build(),
     "+---+---+---+"
@@ -363,8 +363,8 @@ test_table!(
     _2x3_zero_span_at_the_end_1,
     grid(2, 3)
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 3);
-            cfg.set_column_span((1, 0), 3);
+            cfg.set_column_span(pos(0, 0), 3);
+            cfg.set_column_span(pos(1, 0), 3);
         })
         .build(),
     "+-+++"
@@ -379,8 +379,8 @@ test_table!(
     grid(2, 2)
         .data([["123", ""], ["asd", "asd"]])
         .config(|cfg| {
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
         })
         .build(),
     "+-+-+"
@@ -395,8 +395,8 @@ test_table!(
     grid(2, 2)
         .data([["123", ""], ["asd", "asd"]])
         .config(|cfg| {
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+---++"
@@ -409,8 +409,8 @@ test_table!(
     grid(2, 2)
         .data([["123", "axc"], ["asd", "asd"]])
         .config(|cfg| {
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+---+---+"
@@ -421,7 +421,7 @@ test_table!(
 test_table!(
     zero_span_is_not_handled,
     grid(2, 2)
-        .config(|cfg| { cfg.set_column_span((0, 1), 0); })
+        .config(|cfg| { cfg.set_column_span(pos(0, 1), 0); })
         .build(),
     "+---+---+"
     "|0-0|0-1|"
diff --git a/papergrid/tests/grid/format_configuration.rs b/papergrid/tests/grid/format_configuration.rs
index 288839c..0a669ae 100644
--- a/papergrid/tests/grid/format_configuration.rs
+++ b/papergrid/tests/grid/format_configuration.rs
@@ -1,6 +1,6 @@
 #![cfg(feature = "std")]
 
-use papergrid::config::{AlignmentHorizontal, AlignmentVertical, Entity, Formatting};
+use papergrid::config::{pos, AlignmentHorizontal, AlignmentVertical, Entity, Formatting};
 
 use crate::util::grid;
 use testing_table::static_table;
@@ -776,10 +776,10 @@ fn formatting_test() {
     ];
 
     let grid = grid(3, 2)
-        .change_cell((0, 0), "A long string")
-        .change_cell((0, 1), "\n\n\nA\n    string\nwith\n new\nline\n\n\n")
-        .change_cell((2, 0), "A one more\n    string\nwith\n new\nline")
-        .change_cell((2, 1), "...");
+        .change_cell(pos(0, 0), "A long string")
+        .change_cell(pos(0, 1), "\n\n\nA\n    string\nwith\n new\nline\n\n\n")
+        .change_cell(pos(2, 0), "A one more\n    string\nwith\n new\nline")
+        .change_cell(pos(2, 1), "...");
 
     for (i, test) in tests.iter().enumerate() {
         let table = grid
diff --git a/papergrid/tests/grid/render.rs b/papergrid/tests/grid/render.rs
index dd71200..8d289f1 100644
--- a/papergrid/tests/grid/render.rs
+++ b/papergrid/tests/grid/render.rs
@@ -16,8 +16,9 @@ use std::vec;
 
 use papergrid::{
     colors::NoColors,
-    config::spanned::SpannedConfig,
-    config::{AlignmentHorizontal, AlignmentVertical, Borders, Entity},
+    config::{
+        pos, spanned::SpannedConfig, AlignmentHorizontal, AlignmentVertical, Borders, Entity,
+    },
     grid::iterable::Grid,
     records::IterRecords,
 };
@@ -29,7 +30,7 @@ test_table!(render_0x0, grid(0, 0).build(), "");
 
 test_table!(
     render_1x1,
-    grid(1, 1).change_cell((0, 0), "one line").build(),
+    grid(1, 1).change_cell(pos(0, 0), "one line").build(),
     "+--------+"
     "|one line|"
     "+--------+"
@@ -37,7 +38,7 @@ test_table!(
 
 test_table!(
     render_1x1_empty,
-    grid(1, 1).change_cell((0, 0), "").build(),
+    grid(1, 1).change_cell(pos(0, 0), "").build(),
     "++"
     "||"
     "++"
@@ -190,7 +191,7 @@ test_table!(
 
 test_table!(
     render_empty_cell,
-    grid(2, 2).change_cell((0, 1), "").build(),
+    grid(2, 2).change_cell(pos(0, 1), "").build(),
     "+---+---+"
     "|0-0|   |"
     "+---+---+"
@@ -237,7 +238,7 @@ test_table!(
 
 test_table!(
     doesnt_render_return_carige_0,
-    grid(2, 2).change_cell((0, 1), "123\r\r\r567").build(),
+    grid(2, 2).change_cell(pos(0, 1), "123\r\r\r567").build(),
     "+---+---------+"
     "|0-0|123\r\r\r567|"
     "+---+---------+"
@@ -247,7 +248,7 @@ test_table!(
 
 test_table!(
     doesnt_render_return_carige_1,
-    grid(2, 2).change_cell((1, 1), "12345678").change_cell((0, 1), "123\r\r\r567").build(),
+    grid(2, 2).change_cell(pos(1, 1), "12345678").change_cell(pos(0, 1), "123\r\r\r567").build(),
     "+---+---------+"
     "|0-0|123\r\r\r567|"
     "+---+---------+"
diff --git a/papergrid/tests/grid/row_span.rs b/papergrid/tests/grid/row_span.rs
index 054ee2a..ce435d8 100644
--- a/papergrid/tests/grid/row_span.rs
+++ b/papergrid/tests/grid/row_span.rs
@@ -1,7 +1,7 @@
 #![cfg(feature = "std")]
 
 use papergrid::config::{
-    AlignmentHorizontal, AlignmentVertical, Borders,
+    pos, AlignmentHorizontal, AlignmentVertical, Borders,
     Entity::{self, *},
     Indent, Sides,
 };
@@ -13,7 +13,7 @@ test_table!(
     _2x2_vertical_alignment_center,
     grid(2, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Center);
         })
         .build(),
@@ -28,7 +28,7 @@ test_table!(
     _2x2_vertical_alignment_bottom,
     grid(2, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Bottom);
         })
         .build(),
@@ -42,9 +42,9 @@ test_table!(
 test_table!(
     _2x2_multiline,
     grid(2, 2)
-        .change_cell((0, 0), "0-0\n0-1xxx")
+        .change_cell(pos(0, 0), "0-0\n0-1xxx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Center);
         })
         .build(),
@@ -58,9 +58,9 @@ test_table!(
 test_table!(
     _2x2_multiline_vertical_alignment_bottom,
     grid(2, 2)
-        .change_cell((0, 0), "0-0\n0-1xxx")
+        .change_cell(pos(0, 0), "0-0\n0-1xxx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Bottom);
         })
         .build(),
@@ -81,8 +81,8 @@ test_table!(
             ["3-0", "3-1", ""],
         ])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 2), 4);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 2), 4);
         })
         .build(),
     "+----------+---+--------------+"
@@ -100,7 +100,7 @@ test_table!(
     _3x2_with_horizontal_ident_on_spanned_cell,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_padding(Cell(1, 0), Sides::new(Indent::spaced(4), Indent::spaced(4), Indent::default(), Indent::default()));
         })
         .build(),
@@ -117,7 +117,7 @@ test_table!(
     _3x2_with_horizontal_ident,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_padding(Cell(0, 0), Sides::new(Indent::spaced(4), Indent::spaced(4), Indent::default(), Indent::default()));
         })
         .build(),
@@ -134,7 +134,7 @@ test_table!(
     _3x2_with_vertical_ident,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_padding(Cell(0, 0), Sides::new(Indent::default(), Indent::default(), Indent::spaced(4), Indent::spaced(4)));
         })
         .build(),
@@ -157,9 +157,9 @@ test_table!(
     _3x3_render_0,
     grid(3, 3)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 3);
-            cfg.set_row_span((0, 1), 2);
-            cfg.set_row_span((0, 2), 2);
+            cfg.set_row_span(pos(0, 0), 3);
+            cfg.set_row_span(pos(0, 1), 2);
+            cfg.set_row_span(pos(0, 2), 2);
         })
         .build(),
     "+---+---+---+"
@@ -172,11 +172,11 @@ test_table!(
 test_table!(
     _3x3_render_1,
     grid(3, 3)
-        .change_cell((0, 1), "t\ne\nx\nt")
+        .change_cell(pos(0, 1), "t\ne\nx\nt")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 3);
-            cfg.set_row_span((0, 1), 2);
-            cfg.set_row_span((0, 2), 2);
+            cfg.set_row_span(pos(0, 0), 3);
+            cfg.set_row_span(pos(0, 1), 2);
+            cfg.set_row_span(pos(0, 2), 2);
         })
         .build(),
     "+---+---+---+"
@@ -192,10 +192,10 @@ test_table!(
 test_table!(
     _3x3_coliison_0,
     grid(3, 3)
-        .change_cell((0, 0), "0-0xxxxxxx")
+        .change_cell(pos(0, 0), "0-0xxxxxxx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((1, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(1, 1), 2);
         })
         .build(),
     "+----------+---+---+"
@@ -210,10 +210,10 @@ test_table!(
 test_table!(
     _3x3_coliison_1,
     grid(3, 3)
-        .change_cell((1, 1), "1-1xxxxxxx")
+        .change_cell(pos(1, 1), "1-1xxxxxxx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((1, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(1, 1), 2);
         })
         .build(),
     "+---+----------+---+"
@@ -228,11 +228,11 @@ test_table!(
 test_table!(
     _3x3_coliison_2,
     grid(3, 3)
-        .change_cell((1, 1), "1-1\nx\nx\nxxxxx")
-        .change_cell((0, 2), "2-0x\nxxx\nxx\nxxxxxxx")
+        .change_cell(pos(1, 1), "1-1\nx\nx\nxxxxx")
+        .change_cell(pos(0, 2), "2-0x\nxxx\nxx\nxxxxxxx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((1, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(1, 1), 2);
         })
         .build(),
     "+---+-----+-------+"
@@ -251,10 +251,10 @@ test_table!(
 test_table!(
     _3x3_coliison_3,
     grid(3, 3)
-        .change_cell((1, 2), "2-1\nxx\nxx\nxx\nxxxxxx\nx")
+        .change_cell(pos(1, 2), "2-1\nxx\nxx\nxx\nxxxxxx\nx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((1, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(1, 1), 2);
         })
         .build(),
     "+---+---+------+"
@@ -274,10 +274,10 @@ test_table!(
 test_table!(
     _3x3_coliison_4,
     grid(3, 3)
-        .change_cell((2, 1), "0-2\nx\nx\nx\nx\nxxxxxxx\nx\nx")
+        .change_cell(pos(2, 1), "0-2\nx\nx\nx\nx\nxxxxxxx\nx\nx")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((1, 2), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(1, 2), 2);
         })
         .build(),
     "+---+-------+---+"
@@ -299,8 +299,8 @@ test_table!(
 test_table!(
     _3x3_first_row,
     grid(3, 3)
-        .change_cell((0, 0), "0-0\nxx\nx\nx\nx\nx\nx")
-        .config(|cfg|{ cfg.set_row_span((0, 0), 2); })
+        .change_cell(pos(0, 0), "0-0\nxx\nx\nx\nx\nx\nx")
+        .config(|cfg|{ cfg.set_row_span(pos(0, 0), 2); })
         .build(),
     "+---+---+---+"
     "|0-0|0-1|0-2|"
@@ -318,13 +318,13 @@ test_table!(
 test_table!(
     _2x3_with_different_length,
     grid(2, 3)
-        .change_cell((0, 0), "f\nir\nst\n ro\nw")
-        .change_cell((0, 2), "a\n \nlonger\n \nsecond\n \nrow")
-        .change_cell((1, 0), "0")
-        .change_cell((1, 1), "1")
+        .change_cell(pos(0, 0), "f\nir\nst\n ro\nw")
+        .change_cell(pos(0, 2), "a\n \nlonger\n \nsecond\n \nrow")
+        .change_cell(pos(1, 0), "0")
+        .change_cell(pos(1, 1), "1")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 2), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 2), 2);
         })
         .build(),
     "+---+---+------+"
@@ -341,11 +341,11 @@ test_table!(
 test_table!(
     _2x2_with_odd_length,
     grid(2, 2)
-        .change_cell((0, 0), "3\n \n \n ")
-        .change_cell((0, 1), "2")
-        .change_cell((1, 1), "4")
+        .change_cell(pos(0, 0), "3\n \n \n ")
+        .change_cell(pos(0, 1), "2")
+        .change_cell(pos(1, 1), "4")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
         })
         .build(),
     "+-+-+"
@@ -360,9 +360,9 @@ test_table!(
     _2x3_only_col_spaned,
     grid(2, 3)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
-            cfg.set_row_span((0, 2), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
+            cfg.set_row_span(pos(0, 2), 2);
         })
         .build(),
     "+---+---+---+"
@@ -373,9 +373,9 @@ test_table!(
 test_table!(
     _2x2_render_0,
     grid(2, 2)
-        .change_cell((0, 0), "1\n\n\n\n\n\n\n23")
+        .change_cell(pos(0, 0), "1\n\n\n\n\n\n\n23")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
         })
         .build(),
     "+--+---+"
@@ -395,8 +395,8 @@ test_table!(
     grid(2, 2)
         .data([["12\n3\n4", "a\ns\ndw"], ["asd", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+--+--+"
@@ -411,8 +411,8 @@ test_table!(
     grid(2, 2)
         .data([["1", "a"], ["asd", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+-+-+"
@@ -425,8 +425,8 @@ test_table!(
     grid(2, 2)
         .data([["1as\nd\n", "a"], ["as\ndasdds\na", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+---+-+"
@@ -441,8 +441,8 @@ test_table!(
     grid(2, 2)
         .data([["1as\nd\n", "a"], ["as\ndasdds\na", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
             cfg.set_alignment_vertical(Entity::Global, AlignmentVertical::Center)
         })
         .build(),
@@ -458,8 +458,8 @@ test_table!(
     grid(2, 2)
         .data([["1a\ns\nd\n", "a"], ["as\ndasdds\na", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
             cfg.set_alignment_vertical(Entity::Global, AlignmentVertical::Center)
         })
         .build(),
@@ -476,8 +476,8 @@ test_table!(
     grid(2, 2)
         .data([["1a\ns\nd", "a"], ["as\ndasdds\na", "asd"]])
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
             cfg.set_alignment_vertical(Entity::Global, AlignmentVertical::Bottom)
         })
         .build(),
@@ -491,10 +491,10 @@ test_table!(
 test_table!(
     _2x2_with_no_split_style,
     grid(2, 2)
-        .change_cell((0, 0), "1\n2\n3")
+        .change_cell(pos(0, 0), "1\n2\n3")
         .config(|cfg|{
             cfg.set_borders(Borders::default());
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Center);
         })
         .build(),
@@ -507,7 +507,7 @@ test_table!(
     _3x2_with_zero_row_span_0,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
         })
         .build(),
     "+---+---+"
@@ -523,8 +523,8 @@ test_table!(
     _3x2_with_zero_row_span_1,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+---+---+"
@@ -538,7 +538,7 @@ test_table!(
     _3x2_with_zero_row_span_2,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 1), 3);
+            cfg.set_row_span(pos(0, 1), 3);
         })
         .build(),
     "+---+---+"
@@ -554,8 +554,8 @@ test_table!(
     _3x2_with_zero_row_span_3,
     grid(3, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 1), 3);
-            cfg.set_row_span((0, 0), 3);
+            cfg.set_row_span(pos(0, 1), 3);
+            cfg.set_row_span(pos(0, 0), 3);
         })
         .build(),
     "+---+---+"
@@ -568,8 +568,8 @@ test_table!(
     _2x2_with_zero_row_span_4,
     grid(2, 2)
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 1), 2);
         })
         .build(),
     "+---+---+"
@@ -580,10 +580,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_0,
     grid(4, 4)
-        .change_cell((1, 1), "123\n345\n555\n333")
+        .change_cell(pos(1, 1), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((1, 1), 2);
-            cfg.set_column_span((1, 1), 2);
+            cfg.set_row_span(pos(1, 1), 2);
+            cfg.set_column_span(pos(1, 1), 2);
             cfg.set_alignment_horizontal(Cell(1, 1), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(1, 1), AlignmentVertical::Center);
         })
@@ -603,10 +603,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_1,
     grid(4, 4)
-        .change_cell((0, 0), "123\n345\n555\n333")
+        .change_cell(pos(0, 0), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_column_span((0, 0), 2);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
             cfg.set_alignment_horizontal(Cell(0, 0), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Center);
         })
@@ -626,10 +626,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_2,
     grid(4, 4)
-        .change_cell((2, 0), "123\n345\n555\n333")
+        .change_cell(pos(2, 0), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((2, 0), 2);
-            cfg.set_column_span((2, 0), 2);
+            cfg.set_row_span(pos(2, 0), 2);
+            cfg.set_column_span(pos(2, 0), 2);
             cfg.set_alignment_horizontal(Cell(2, 0), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(2, 0), AlignmentVertical::Center);
         })
@@ -649,10 +649,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_3,
     grid(4, 4)
-        .change_cell((2, 2), "123\n345\n555\n333")
+        .change_cell(pos(2, 2), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((2, 2), 2);
-            cfg.set_column_span((2, 2), 2);
+            cfg.set_row_span(pos(2, 2), 2);
+            cfg.set_column_span(pos(2, 2), 2);
             cfg.set_alignment_horizontal(Cell(2, 2), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(2, 2), AlignmentVertical::Center);
         })
@@ -672,10 +672,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_4,
     grid(4, 4)
-        .change_cell((0, 2), "123\n345\n555\n333")
+        .change_cell(pos(0, 2), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((0, 2), 2);
-            cfg.set_column_span((0, 2), 2);
+            cfg.set_row_span(pos(0, 2), 2);
+            cfg.set_column_span(pos(0, 2), 2);
             cfg.set_alignment_horizontal(Cell(0, 2), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(0, 2), AlignmentVertical::Center);
         })
@@ -695,10 +695,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_5,
     grid(4, 4)
-        .change_cell((0, 1), "123\n345\n555\n333")
+        .change_cell(pos(0, 1), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((0, 1), 2);
-            cfg.set_column_span((0, 1), 2);
+            cfg.set_row_span(pos(0, 1), 2);
+            cfg.set_column_span(pos(0, 1), 2);
             cfg.set_alignment_horizontal(Cell(0, 1), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(0, 1), AlignmentVertical::Center);
         })
@@ -718,10 +718,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_6,
     grid(4, 4)
-        .change_cell((1, 1), "123\n345\n555\n333")
+        .change_cell(pos(1, 1), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((1, 1), 3);
-            cfg.set_column_span((1, 1), 3);
+            cfg.set_row_span(pos(1, 1), 3);
+            cfg.set_column_span(pos(1, 1), 3);
             cfg.set_alignment_horizontal(Cell(1, 1), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(1, 1), AlignmentVertical::Center);
         })
@@ -740,10 +740,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_7,
     grid(4, 4)
-        .change_cell((0, 0), "123\n345\n555\n333")
+        .change_cell(pos(0, 0), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((0, 0), 3);
-            cfg.set_column_span((0, 0), 3);
+            cfg.set_row_span(pos(0, 0), 3);
+            cfg.set_column_span(pos(0, 0), 3);
             cfg.set_alignment_horizontal(Cell(0, 0), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(0, 0), AlignmentVertical::Center);
         })
@@ -762,10 +762,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_8,
     grid(4, 4)
-        .change_cell((0, 1), "123\n345\n555\n333")
+        .change_cell(pos(0, 1), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((0, 1), 3);
-            cfg.set_column_span((0, 1), 3);
+            cfg.set_row_span(pos(0, 1), 3);
+            cfg.set_column_span(pos(0, 1), 3);
             cfg.set_alignment_horizontal(Cell(0, 1), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(0, 1), AlignmentVertical::Center);
         })
@@ -784,10 +784,10 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_9,
     grid(4, 4)
-        .change_cell((1, 0), "123\n345\n555\n333")
+        .change_cell(pos(1, 0), "123\n345\n555\n333")
         .config(|cfg|{
-            cfg.set_row_span((1, 0), 3);
-            cfg.set_column_span((1, 0), 3);
+            cfg.set_row_span(pos(1, 0), 3);
+            cfg.set_column_span(pos(1, 0), 3);
             cfg.set_alignment_horizontal(Cell(1, 0), AlignmentHorizontal::Center);
             cfg.set_alignment_vertical(Cell(1, 0), AlignmentVertical::Center);
         })
@@ -806,12 +806,12 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_10,
     grid(4, 4)
-        .change_cell((0, 0), "hello\nworld\n!\n!\n!\n!")
+        .change_cell(pos(0, 0), "hello\nworld\n!\n!\n!\n!")
         .config(|cfg|{
-            cfg.set_column_span((1, 1), 2);
-            cfg.set_column_span((3, 0), 3);
-            cfg.set_row_span((0, 0), 2);
-            cfg.set_row_span((0, 3), 3);
+            cfg.set_column_span(pos(1, 1), 2);
+            cfg.set_column_span(pos(3, 0), 3);
+            cfg.set_row_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 3), 3);
         })
         .build(),
     "+-----+---+---+---+"
@@ -831,12 +831,12 @@ test_table!(
 test_table!(
     _4x4_with_row_span_and_col_span_11,
     grid(4, 4)
-        .change_cell((0, 2), "q\nw\ne\nr\nt")
-        .change_cell((0, 3), "q1\nw1\ne1\nr1\nt1")
+        .change_cell(pos(0, 2), "q\nw\ne\nr\nt")
+        .change_cell(pos(0, 3), "q1\nw1\ne1\nr1\nt1")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_row_span((0, 2), 2);
-            cfg.set_row_span((0, 3), 3);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 2), 2);
+            cfg.set_row_span(pos(0, 3), 3);
         })
         .build(),
     "+---+---+---+---+"
@@ -855,12 +855,12 @@ test_table!(
 test_table!(
     _3x5_with_row_span_and_col_span_12,
     grid(3, 5)
-        .change_cell((0, 3), "q\nw\ne\nr\nt")
-        .change_cell((0, 4), "q1\nw1\ne1\nr1\nt1")
+        .change_cell(pos(0, 3), "q\nw\ne\nr\nt")
+        .change_cell(pos(0, 4), "q1\nw1\ne1\nr1\nt1")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_row_span((0, 3), 2);
-            cfg.set_row_span((0, 4), 3);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 3), 2);
+            cfg.set_row_span(pos(0, 4), 3);
         })
         .build(),
     "+---+---+---+---+--+"
@@ -877,12 +877,12 @@ test_table!(
 test_table!(
     _3x5_with_row_span_and_col_span_13,
     grid(3, 5)
-        .change_cell((0, 3), "q\nw\ne\nr\nt\n")
-        .change_cell((0, 4), "q1\nw1\ne1\nr1\nt1\n")
+        .change_cell(pos(0, 3), "q\nw\ne\nr\nt\n")
+        .change_cell(pos(0, 4), "q1\nw1\ne1\nr1\nt1\n")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_row_span((0, 3), 2);
-            cfg.set_row_span((0, 4), 3);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 3), 2);
+            cfg.set_row_span(pos(0, 4), 3);
         })
         .build(),
     "+---+---+---+---+--+"
@@ -900,12 +900,12 @@ test_table!(
 test_table!(
     _3x5_with_row_span_and_col_span_14,
     grid(3, 5)
-        .change_cell((0, 3), "q\nw\ne\nr\nt\n")
-        .change_cell((0, 4), "q1\nw1\ne1\nr1\nt1\n")
+        .change_cell(pos(0, 3), "q\nw\ne\nr\nt\n")
+        .change_cell(pos(0, 4), "q1\nw1\ne1\nr1\nt1\n")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_row_span((0, 3), 2);
-            cfg.set_row_span((0, 4), 3);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_row_span(pos(0, 3), 2);
+            cfg.set_row_span(pos(0, 4), 3);
             cfg.set_padding(
                 Cell(0, 0),
                 Sides::new(Indent::new(2, ' '), Indent::new(2, ' '), Indent::new(2, ' '), Indent::new(2, ' '))
@@ -944,9 +944,9 @@ test_table!(
     _3x4_with_row_span_and_col_span_13,
     grid(3, 5)
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
-            cfg.set_row_span((1, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
+            cfg.set_row_span(pos(1, 0), 2);
         })
         .build(),
     "+-+-+---+---+---+"
@@ -961,9 +961,9 @@ test_table!(
 test_table!(
     _5x2_render_0,
     grid(5, 2)
-        .change_cell((1, 1), "1\n2\n3\n4")
+        .change_cell(pos(1, 1), "1\n2\n3\n4")
         .config(|cfg|{
-            cfg.set_row_span((1, 1), 4);
+            cfg.set_row_span(pos(1, 1), 4);
         })
         .build(),
     "+---+---+"
@@ -983,9 +983,9 @@ test_table!(
     _3x4_column_span_0,
     grid(3, 4)
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 2);
-            cfg.set_column_span((1, 0), 2);
-            cfg.set_column_span((2, 0), 2);
+            cfg.set_column_span(pos(0, 0), 2);
+            cfg.set_column_span(pos(1, 0), 2);
+            cfg.set_column_span(pos(2, 0), 2);
         })
         .build(),
     "+-+-+---+---+"
@@ -1001,9 +1001,9 @@ test_table!(
     _3x4_column_span_1,
     grid(3, 4)
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 3);
-            cfg.set_column_span((1, 0), 3);
-            cfg.set_column_span((2, 0), 3);
+            cfg.set_column_span(pos(0, 0), 3);
+            cfg.set_column_span(pos(1, 0), 3);
+            cfg.set_column_span(pos(2, 0), 3);
         })
         .build(),
     "+-+++---+"
@@ -1018,13 +1018,13 @@ test_table!(
 test_table!(
     _3x4_column_span_2,
     grid(3, 4)
-        .change_cell((0, 0), "")
-        .change_cell((1, 0), "")
-        .change_cell((2, 0), "")
+        .change_cell(pos(0, 0), "")
+        .change_cell(pos(1, 0), "")
+        .change_cell(pos(2, 0), "")
         .config(|cfg|{
-            cfg.set_column_span((0, 0), 3);
-            cfg.set_column_span((1, 0), 3);
-            cfg.set_column_span((2, 0), 3);
+            cfg.set_column_span(pos(0, 0), 3);
+            cfg.set_column_span(pos(1, 0), 3);
+            cfg.set_column_span(pos(2, 0), 3);
         })
         .build(),
     "++++---+"
diff --git a/papergrid/tests/grid/settings.rs b/papergrid/tests/grid/settings.rs
index fa9d085..35fa45f 100644
--- a/papergrid/tests/grid/settings.rs
+++ b/papergrid/tests/grid/settings.rs
@@ -1,7 +1,7 @@
 #![cfg(feature = "std")]
 
 use papergrid::ansi::ANSIBuf;
-use papergrid::config::{AlignmentHorizontal, Border, Borders, Entity, Indent, Sides};
+use papergrid::config::{pos, AlignmentHorizontal, Border, Borders, Entity, Indent, Sides};
 
 use crate::util::grid;
 use testing_table::test_table;
@@ -38,7 +38,7 @@ test_table!(
         .config(|cfg| {
             cfg.set_borders(Borders::default());
             cfg.set_border(
-                (0, 0),
+                pos(0, 0),
                 Border {
                     top: Some('x'),
                     bottom: Some('o'),
@@ -47,7 +47,7 @@ test_table!(
                 },
             );
 
-            cfg.remove_border((0, 0), (2, 2));
+            cfg.remove_border(pos(0, 0), (2, 2));
         })
         .build(),
     "0-00-1\n1-01-1"
diff --git a/papergrid/tests/grid/styling.rs b/papergrid/tests/grid/styling.rs
index 7e1ee8c..088448b 100644
--- a/papergrid/tests/grid/styling.rs
+++ b/papergrid/tests/grid/styling.rs
@@ -1,6 +1,6 @@
 #![cfg(feature = "std")]
 
-use papergrid::config::{AlignmentHorizontal, Border, Borders, Entity, Indent, Sides};
+use papergrid::config::{pos, AlignmentHorizontal, Border, Borders, Entity, Indent, Sides};
 
 use crate::util::grid;
 use testing_table::test_table;
@@ -11,7 +11,7 @@ use ::{owo_colors::OwoColorize, papergrid::ansi::ANSIBuf, std::convert::TryFrom}
 test_table!(
     grid_2x2_custom_frame_test,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|r| (0..2).for_each(|c| cfg.set_border((r, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#')))))
+        .config(|cfg| (0..2).for_each(|r| (0..2).for_each(|c| cfg.set_border(pos(r, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#')))))
         .build(),
     "#***#***#"
     "|0-0|0-1|"
@@ -23,7 +23,7 @@ test_table!(
 test_table!(
     grid_2x2_custom_column_test_0,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|r| cfg.set_border((r, 1), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
+        .config(|cfg| (0..2).for_each(|r| cfg.set_border(pos(r, 1), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
         .build(),
     "+---#***#"
     "|0-0|0-1|"
@@ -35,7 +35,7 @@ test_table!(
 test_table!(
     grid_2x2_custom_column_test_1,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|r| cfg.set_border((r, 0), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
+        .config(|cfg| (0..2).for_each(|r| cfg.set_border(pos(r, 0), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
         .build(),
     "#***#---+"
     "|0-0|0-1|"
@@ -47,7 +47,7 @@ test_table!(
 test_table!(
     grid_2x2_custom_row_test_0,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|c| cfg.set_border((0, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
+        .config(|cfg| (0..2).for_each(|c| cfg.set_border(pos(0, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
         .build(),
     "#***#***#"
     "|0-0|0-1|"
@@ -59,7 +59,7 @@ test_table!(
 test_table!(
     grid_2x2_custom_row_test_1,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|c| cfg.set_border((1, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
+        .config(|cfg| (0..2).for_each(|c| cfg.set_border(pos(1, c), Border::full('*', '*', '|', '|', '#', '#', '#', '#'))))
         .build(),
     "+---+---+"
     "|0-0|0-1|"
@@ -71,7 +71,7 @@ test_table!(
 test_table!(
     grid_2x2_change_cell_border_test_0,
     grid(2, 2)
-        .config(|cfg| (0..2).for_each(|_| cfg.set_border((0, 1), Border::full('*', '^', '@', '#', '~', '!', '%', '&'))))
+        .config(|cfg| (0..2).for_each(|_| cfg.set_border(pos(0, 1), Border::full('*', '^', '@', '#', '~', '!', '%', '&'))))
         .build(),
     "+---~***!"
     "|0-0@0-1#"
@@ -83,8 +83,8 @@ test_table!(
 test_table!(
     grid_2x2_alignment_test_0,
     grid(2, 2)
-        .change_cell((0, 0), "asd    ")
-        .change_cell((0, 1), "asd    ")
+        .change_cell(pos(0, 0), "asd    ")
+        .change_cell(pos(0, 1), "asd    ")
         .config(|cfg| {
             cfg.set_alignment_horizontal(Entity::Column(0), AlignmentHorizontal::Left);
             cfg.set_alignment_horizontal(Entity::Column(1), AlignmentHorizontal::Right);
@@ -147,7 +147,7 @@ test_table!(
 
 test_table!(
     grid_2x2_vertical_resize_test,
-    grid(2, 2).change_cell((1, 1), "asd     ").build(),
+    grid(2, 2).change_cell(pos(1, 1), "asd     ").build(),
     "+---+--------+"
     "|0-0|0-1     |"
     "+---+--------+"
@@ -191,7 +191,7 @@ test_table!(
     grid(2, 2)
         .config(|cfg| {
             cfg.set_border(
-                (0, 0),
+                pos(0, 0),
                 Border {
                     bottom: Some('-'),
                     top: Some('*'),
@@ -202,11 +202,11 @@ test_table!(
                 },
             );
             cfg.set_border(
-                (0, 1),
+                pos(0, 1),
                 Border::full('*', '-', '@', '%', ' ', ' ', '+', '+'),
             );
             cfg.set_border(
-                (1, 0),
+                pos(1, 0),
                 Border {
                     bottom: Some('*'),
                     left: Some('#'),
@@ -216,7 +216,7 @@ test_table!(
                 },
             );
             cfg.set_border(
-                (1, 1),
+                pos(1, 1),
                 Border {
                     bottom: Some('*'),
                     left: Some('^'),
@@ -246,7 +246,7 @@ test_table!(
                 ..Default::default()
             });
             cfg.set_border(
-                (1, 1),
+                pos(1, 1),
                 Border {
                     top: Some('*'),
                     ..Default::default()
@@ -265,7 +265,7 @@ test_table!(
         .config(|cfg| {
             cfg.set_borders(Borders::default());
             cfg.set_border(
-                (1, 0),
+                pos(1, 0),
                 Border {
                     right: Some('*'),
                     ..Default::default()
@@ -292,8 +292,8 @@ test_table!(
                 let bl = ANSIBuf::try_from(" ".yellow().to_string()).unwrap();
                 let br = ANSIBuf::try_from(" ".on_yellow().to_string()).unwrap();
 
-                cfg.set_border((r, c), Border::full('*', '#', '~', '!', '@', '$', '%', '^'));
-                cfg.set_border_color((r, c), Border::full(top, bottom, left, right, tl, tr, bl, br));
+                cfg.set_border((r, c).into(), Border::full('*', '#', '~', '!', '@', '$', '%', '^'));
+                cfg.set_border_color((r, c).into(), Border::full(top, bottom, left, right, tl, tr, bl, br));
             }))
         })
         .build(),
diff --git a/papergrid/tests/util/grid_builder.rs b/papergrid/tests/util/grid_builder.rs
index c2a82b8..7220731 100644
--- a/papergrid/tests/util/grid_builder.rs
+++ b/papergrid/tests/util/grid_builder.rs
@@ -1,14 +1,12 @@
 #![cfg(feature = "std")]
-#![allow(dead_code, unused_macros, unused_imports)]
+#![allow(unused_macros, unused_imports)]
 
 use std::collections::HashMap;
 
 use papergrid::{
     colors::NoColors,
-    config::spanned::SpannedConfig,
-    config::{Borders, Position},
-    dimension::spanned::SpannedGridDimension,
-    dimension::{Dimension, Estimate},
+    config::{pos, spanned::SpannedConfig, Borders, Position},
+    dimension::{spanned::SpannedGridDimension, Dimension, Estimate},
     grid::iterable::Grid,
     records::{IterRecords, Records},
 };
@@ -48,7 +46,7 @@ impl GridBuilder {
         for (i, rows) in data.into_iter().enumerate() {
             for (j, text) in rows.into_iter().enumerate() {
                 let text = text.into();
-                self.data.insert((i, j), text);
+                self.data.insert(pos(i, j), text);
             }
         }
 
@@ -62,8 +60,8 @@ impl GridBuilder {
 
     pub fn build(self) -> String {
         let mut data = records(self.size.0, self.size.1);
-        for ((row, col), text) in self.data {
-            data[row][col] = text;
+        for (p, text) in self.data {
+            data[p.row()][p.col()] = text;
         }
 
         let grid = build_grid(data, self.cfg, self.size);
diff --git a/tabled/tests/core/extended_table_test.rs b/tabled/tests/core/extended_table_test.rs
index 5a303ff..ca57ca2 100644
--- a/tabled/tests/core/extended_table_test.rs
+++ b/tabled/tests/core/extended_table_test.rs
@@ -247,7 +247,7 @@ fn display_multiline_record_value() {
 test_table!(
     display_with_truncate,
     {
-        let data = Matrix::new(3, 3).insert((1, 0), "a long string").to_vec();
+        let data = Matrix::new(3, 3).insert((1, 0).into(), "a long string").to_vec();
         let mut table = ExtendedTable::from(data);
         table.truncate(14, "");
         table.to_string()
@@ -272,7 +272,7 @@ test_table!(
 test_table!(
     truncate_with_suffix,
     {
-        let data = Matrix::new(3, 3).insert((1, 0), "a long string").to_vec();
+        let data = Matrix::new(3, 3).insert((1, 0).into(), "a long string").to_vec();
         let mut table = ExtendedTable::from(data);
         table.truncate(15, "..");
         table.to_string()
@@ -380,7 +380,7 @@ fn truncate_big_fields() {
 test_table!(
     truncate_too_small,
     {
-        let data = Matrix::new(3, 3).insert((1, 0), "a long string").to_vec();
+        let data = Matrix::new(3, 3).insert((1, 0).into(), "a long string").to_vec();
         let mut table = ExtendedTable::from(data);
         let success = table.truncate(2, "");
         assert!(!success);
diff --git a/tabled/tests/matrix/matrix.rs b/tabled/tests/matrix/matrix.rs
index a99ee48..0c59257 100644
--- a/tabled/tests/matrix/matrix.rs
+++ b/tabled/tests/matrix/matrix.rs
@@ -77,7 +77,7 @@ impl Matrix {
     }
 
     pub fn insert<V: ToString>(mut self, pos: tabled::grid::config::Position, value: V) -> Self {
-        self.data[pos.0][pos.1] = value.to_string();
+        self.data[pos.row()][pos.col()] = value.to_string();
         self
     }
 
diff --git a/tabled/tests/settings/alignment_test.rs b/tabled/tests/settings/alignment_test.rs
index 0fa168b..88d04de 100644
--- a/tabled/tests/settings/alignment_test.rs
+++ b/tabled/tests/settings/alignment_test.rs
@@ -37,7 +37,7 @@ test_table!(
 
 test_table!(
     full_alignment_multiline,
-    Matrix::new(3, 3).insert((3, 2), "https://\nwww\n.\nredhat\n.com\n/en")
+    Matrix::new(3, 3).insert((3, 2).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Segment::all()).with(Alignment::left())),
     " N | column 0 | column 1 | column 2 "
@@ -55,9 +55,9 @@ test_table!(
 test_table!(
     vertical_alignment_test,
     Matrix::new(3, 3)
-        .insert((2, 2), "E\nnde\navou\nros")
-        .insert((3, 2), "Red\nHat")
-        .insert((3, 3), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((2, 2).into(), "E\nnde\navou\nros")
+        .insert((3, 2).into(), "Red\nHat")
+        .insert((3, 3).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Columns::new(1..)).with(Alignment::bottom())),
     " N | column 0 | column 1 | column 2 "
diff --git a/tabled/tests/settings/concat_test.rs b/tabled/tests/settings/concat_test.rs
index b988dca..c0b78fb 100644
--- a/tabled/tests/settings/concat_test.rs
+++ b/tabled/tests/settings/concat_test.rs
@@ -7,7 +7,7 @@ use testing_table::test_table;
 
 test_table!(
     join_vertical_0,
-    Matrix::new(2, 3).insert((1, 0), "123").with(Style::psql())
+    Matrix::new(2, 3).insert((1, 0).into(), "123").with(Style::psql())
         .with(Concat::vertical(Matrix::new(2, 3).to_table()))
         .to_string(),
     "  N  | column 0 | column 1 | column 2 "
@@ -22,7 +22,7 @@ test_table!(
 test_table!(
     join_vertical_1,
     Matrix::new(2, 3)
-        .with(Concat::vertical(Matrix::new(2, 3).insert((1, 0), "123").with(Style::psql()))),
+        .with(Concat::vertical(Matrix::new(2, 3).insert((1, 0).into(), "123").with(Style::psql()))),
     "+-----+----------+----------+----------+"
     "|  N  | column 0 | column 1 | column 2 |"
     "+-----+----------+----------+----------+"
diff --git a/tabled/tests/settings/format_test.rs b/tabled/tests/settings/format_test.rs
index 9d35ffc..ec03cd9 100644
--- a/tabled/tests/settings/format_test.rs
+++ b/tabled/tests/settings/format_test.rs
@@ -64,9 +64,9 @@ test_table!(
 test_table!(
     formatting_multiline_test,
     Matrix::new(3, 3)
-        .insert((2, 2), "E\nnde\navou\nros")
-        .insert((3, 2), "Red\nHat")
-        .insert((3, 3), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((2, 2).into(), "E\nnde\navou\nros")
+        .insert((3, 2).into(), "Red\nHat")
+        .insert((3, 3).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Segment::all()).with(Format::content(|s| format!("(x) {s}")).multiline())),
     " (x) N | (x) column 0 | (x) column 1 | (x) column 2 "
@@ -183,11 +183,14 @@ test_table!(
     format_with_index,
     Matrix::new(3, 3)
         .with(Style::markdown())
-        .with(Modify::new(Rows::first()).with(Format::positioned(|a, (b, c)| match (b, c) {
-            (0, 0) => "(0, 0)".to_string(),
-            (0, 1) => "(0, 1)".to_string(),
-            (0, 2) => "(0, 2)".to_string(),
-            _ => a.to_string(),
+        .with(Modify::new(Rows::first()).with(Format::positioned(|a, p| {
+            let p: (_, _) = p.into();
+            match p {
+                (0, 0) => "(0, 0)".to_string(),
+                (0, 1) => "(0, 1)".to_string(),
+                (0, 2) => "(0, 2)".to_string(),
+                _ => a.to_string(),
+            }
         }))),
     "| (0, 0) | (0, 1) | (0, 2) | column 2 |"
     "|--------|--------|--------|----------|"
@@ -248,9 +251,9 @@ test_table!(
 test_table!(
     color_multiline_test,
     Matrix::new(3, 3)
-        .insert((2, 2), "E\nnde\navou\nros")
-        .insert((3, 2), "Red\nHat")
-        .insert((3, 3), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((2, 2).into(), "E\nnde\navou\nros")
+        .insert((3, 2).into(), "Red\nHat")
+        .insert((3, 3).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Columns::new(..1)).with(Format::content(|s| s.red().to_string()).multiline()))
         .with(Modify::new(Columns::new(1..2)).with(Format::content(|s| s.blue().to_string()).multiline()))
diff --git a/tabled/tests/settings/margin_test.rs b/tabled/tests/settings/margin_test.rs
index 79ac272..4c9a740 100644
--- a/tabled/tests/settings/margin_test.rs
+++ b/tabled/tests/settings/margin_test.rs
@@ -32,7 +32,7 @@ test_table!(
 test_table!(
     margin_without_table_based_on_grid_borders,
     Matrix::new(3, 3)
-        .insert((3, 2), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((3, 2).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Cell::new(3, 2)).with(Span::column(2)))
         .with(Margin::new(1, 1, 1, 1).fill('>', '<', 'V', '^')),
@@ -53,7 +53,7 @@ test_table!(
 test_table!(
     table_with_empty_margin,
     Matrix::new(3, 3)
-        .insert((3, 2), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((3, 2).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new(Cell::new(3, 2)).with(Span::column(2)))
         .with(Margin::new(0, 0, 0, 0).fill('>', '<', 'V', '^')),
diff --git a/tabled/tests/settings/span_test.rs b/tabled/tests/settings/span_test.rs
index 15cfcf6..432751d 100644
--- a/tabled/tests/settings/span_test.rs
+++ b/tabled/tests/settings/span_test.rs
@@ -210,7 +210,7 @@ test_table!(
 test_table!(
     span_multiline,
     Matrix::new(3, 3)
-        .insert((3, 2), "https://\nwww\n.\nredhat\n.com\n/en")
+        .insert((3, 2).into(), "https://\nwww\n.\nredhat\n.com\n/en")
         .with(Style::psql())
         .with(Modify::new((3, 2)).with(Span::column(2))),
     " N | column 0 | column 1 | column 2 "
@@ -1256,5 +1256,5 @@ test_table!(
 );
 
 fn create_span_list(count_rows: usize, count_cols: usize) -> impl Iterator<Item = Position> {
-    (0..count_rows).flat_map(move |r| (0..count_cols).map(move |c| (r, c)))
+    (0..count_rows).flat_map(move |r| (0..count_cols).map(move |c| (r, c).into()))
 }
diff --git a/tabled/tests/settings/style_test.rs b/tabled/tests/settings/style_test.rs
index a10c4da..ade7132 100644
--- a/tabled/tests/settings/style_test.rs
+++ b/tabled/tests/settings/style_test.rs
@@ -708,7 +708,7 @@ test_table!(
 test_table!(
     style_settings_usage_test_0,
     Matrix::new(3, 3)
-        .insert((1, 1), "a longer string")
+        .insert((1, 1).into(), "a longer string")
         .with({
             let mut style = Theme::from_style(Style::modern());
             style.set_borders_bottom('a');
@@ -734,7 +734,7 @@ test_table!(
 test_table!(
     style_settings_usage_test_1,
     Matrix::new(3, 3)
-        .insert((1, 1), "a longer string")
+        .insert((1, 1).into(), "a longer string")
         .with({
             let mut style = Theme::from_style(Style::modern());
             style.remove_borders_bottom();
@@ -754,7 +754,7 @@ test_table!(
 test_table!(
     style_settings_usage_test_2,
     Matrix::new(3, 3)
-        .insert((1, 1), "a longer string")
+        .insert((1, 1).into(), "a longer string")
         .with({
             let mut style = Theme::from_style(Style::modern());
             style.remove_borders_bottom();
@@ -1652,7 +1652,7 @@ fn test_default_border_usage() {
     macro_rules! test_border {
         ($modify:expr, $expected:expr) => {
             let table = Matrix::new(3, 3)
-                .insert((1, 1), "a longer string")
+                .insert((1, 1).into(), "a longer string")
                 .with(Style::empty())
                 .with($modify)
                 .to_string();
diff --git a/tabled/tests/settings/width_test.rs b/tabled/tests/settings/width_test.rs
index 19c337b..5f7710e 100644
--- a/tabled/tests/settings/width_test.rs
+++ b/tabled/tests/settings/width_test.rs
@@ -1173,7 +1173,7 @@ fn total_width_wrapping() {
     assert_width!(table, 20);
 
     let table = Matrix::new(3, 3)
-        .insert((3, 2), "some loong string")
+        .insert((3, 2).into(), "some loong string")
         .with(Modify::new(Segment::all()).with(Alignment::center()))
         .with(Style::markdown())
         .with(Width::wrap(20).keep_words(true))
@@ -1298,7 +1298,9 @@ fn total_width_small_with_panel_using_wrapping() {
 
 #[test]
 fn max_width_with_span() {
-    let mut table = Matrix::new(3, 3).insert((1, 1), "a long string").to_table();
+    let mut table = Matrix::new(3, 3)
+        .insert((1, 1).into(), "a long string")
+        .to_table();
     table
         .with(Style::psql())
         .with(Modify::new((1, 1)).with(Span::column(2)))
@@ -1588,8 +1590,8 @@ fn justify_width_constant_test() {
 #[test]
 fn justify_width_constant_different_sizes_test() {
     let table = Matrix::new(3, 3)
-        .insert((1, 1), "Hello World")
-        .insert((3, 2), "multi\nline string\n")
+        .insert((1, 1).into(), "Hello World")
+        .insert((3, 2).into(), "multi\nline string\n")
         .with(Style::markdown())
         .with(Justify::new(3))
         .to_string();
@@ -1668,7 +1670,7 @@ fn justify_width_max_test() {
 #[test]
 fn max_width_when_cell_has_tabs() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "\tHello\tWorld\t")
+        .insert((2, 1).into(), "\tHello\tWorld\t")
         .with(TabSize::new(4))
         .with(Style::markdown())
         .with(Modify::new(Columns::new(..)).with(Width::truncate(1)))
@@ -1689,7 +1691,7 @@ fn max_width_when_cell_has_tabs() {
 #[test]
 fn max_width_table_when_cell_has_tabs() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "\tHello\tWorld\t")
+        .insert((2, 1).into(), "\tHello\tWorld\t")
         .with(TabSize::new(4))
         .with(Style::markdown())
         .with(Width::truncate(15))
@@ -1722,7 +1724,7 @@ fn max_width_table_when_cell_has_tabs() {
 #[test]
 fn max_width_truncate_with_big_span() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line; Here we gooooooo")
+        .insert((2, 1).into(), "Hello World With Big Line; Here we gooooooo")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(3)))
         .with(Width::truncate(40))
@@ -1741,8 +1743,8 @@ fn max_width_truncate_with_big_span() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line; Here we gooooooo")
-        .insert((3, 2), "Hello World With Big Line; Here")
+        .insert((2, 1).into(), "Hello World With Big Line; Here we gooooooo")
+        .insert((3, 2).into(), "Hello World With Big Line; Here")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(3)))
         .with(Modify::new((3, 2)).with(Span::column(2)))
@@ -1760,8 +1762,8 @@ fn max_width_truncate_with_big_span() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line; Here we gooooooo")
-        .insert((3, 2), "Hello World With Big Line; Here")
+        .insert((2, 1).into(), "Hello World With Big Line; Here we gooooooo")
+        .insert((3, 2).into(), "Hello World With Big Line; Here")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(3)))
         .with(Modify::new((3, 2)).with(Span::column(2)))
@@ -1781,8 +1783,8 @@ fn max_width_truncate_with_big_span() {
     assert_eq!(get_text_width(&table), 40);
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line; Here we gooooooo")
-        .insert((3, 2), "Hello World With Big Line; Here")
+        .insert((2, 1).into(), "Hello World With Big Line; Here we gooooooo")
+        .insert((3, 2).into(), "Hello World With Big Line; Here")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Modify::new((3, 2)).with(Span::column(2)))
@@ -1802,8 +1804,8 @@ fn max_width_truncate_with_big_span() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line; Here w")
-        .insert((3, 2), "Hello World With Big L")
+        .insert((2, 1).into(), "Hello World With Big Line; Here w")
+        .insert((3, 2).into(), "Hello World With Big L")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(3)))
         .with(Modify::new((3, 2)).with(Span::column(2)))
@@ -1824,7 +1826,7 @@ fn max_width_truncate_with_big_span() {
 #[test]
 fn max_width_truncate_priority_max() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(35).priority(PriorityMax::right()))
         .to_string();
@@ -1842,7 +1844,7 @@ fn max_width_truncate_priority_max() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(20).priority(PriorityMax::right()))
         .to_string();
@@ -1860,7 +1862,7 @@ fn max_width_truncate_priority_max() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(0).priority(PriorityMax::right()))
         .to_string();
@@ -1881,7 +1883,7 @@ fn max_width_truncate_priority_max() {
 #[test]
 fn max_width_truncate_priority_max_with_span() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Width::truncate(15).priority(PriorityMax::right()))
@@ -1903,7 +1905,7 @@ fn max_width_truncate_priority_max_with_span() {
 #[test]
 fn max_width_wrap_priority_max() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(35).priority(PriorityMax::right()))
         .to_string();
@@ -1925,7 +1927,7 @@ fn max_width_wrap_priority_max() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(20).priority(PriorityMax::right()))
         .to_string();
@@ -1960,7 +1962,7 @@ fn max_width_wrap_priority_max() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(0).priority(PriorityMax::right()))
         .to_string();
@@ -1981,7 +1983,7 @@ fn max_width_wrap_priority_max() {
 #[test]
 fn max_width_wrap_priority_max_with_span() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Width::wrap(15).priority(PriorityMax::right()))
@@ -2020,7 +2022,7 @@ fn max_width_wrap_priority_max_with_span() {
 #[test]
 fn max_width_truncate_priority_min() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(35).priority(PriorityMin::right()))
         .to_string();
@@ -2038,7 +2040,7 @@ fn max_width_truncate_priority_min() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(20).priority(PriorityMin::right()))
         .to_string();
@@ -2056,7 +2058,7 @@ fn max_width_truncate_priority_min() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(0).priority(PriorityMin::right()))
         .to_string();
@@ -2077,7 +2079,7 @@ fn max_width_truncate_priority_min() {
 #[test]
 fn max_width_truncate_priority_min_with_span() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Width::truncate(15).priority(PriorityMin::right()))
@@ -2096,7 +2098,7 @@ fn max_width_truncate_priority_min_with_span() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Width::truncate(17).priority(PriorityMin::right()))
@@ -2118,7 +2120,7 @@ fn max_width_truncate_priority_min_with_span() {
 #[test]
 fn max_width_wrap_priority_min() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(35).priority(PriorityMin::right()))
         .to_string();
@@ -2137,7 +2139,7 @@ fn max_width_wrap_priority_min() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(20).priority(PriorityMin::right()))
         .to_string();
@@ -2159,7 +2161,7 @@ fn max_width_wrap_priority_min() {
     );
 
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::wrap(0).priority(PriorityMin::right()))
         .to_string();
@@ -2180,7 +2182,7 @@ fn max_width_wrap_priority_min() {
 #[test]
 fn max_width_wrap_priority_min_with_span() {
     let table = Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Modify::new((2, 1)).with(Span::column(2)))
         .with(Width::wrap(15).priority(PriorityMin::right()))
@@ -2339,8 +2341,8 @@ fn wrap_keeping_words_0() {
 #[test]
 fn cell_truncate_multiline() {
     let table = Matrix::new(3, 3)
-        .insert((1, 1), "H\nel\nlo World")
-        .insert((3, 2), "multi\nline string\n")
+        .insert((1, 1).into(), "H\nel\nlo World")
+        .insert((3, 2).into(), "multi\nline string\n")
         .with(Style::markdown())
         .with(
             Modify::new(Columns::new(1..2).not(Rows::single(0)))
@@ -2367,8 +2369,8 @@ fn cell_truncate_multiline() {
 #[test]
 fn cell_truncate_multiline_with_suffix() {
     let table = Matrix::new(3, 3)
-        .insert((1, 1), "H\nel\nlo World")
-        .insert((3, 2), "multi\nline string\n")
+        .insert((1, 1).into(), "H\nel\nlo World")
+        .insert((3, 2).into(), "multi\nline string\n")
         .with(Style::markdown())
         .with(
             Modify::new(Columns::new(1..2).not(Rows::single(0)))
@@ -2395,8 +2397,8 @@ fn cell_truncate_multiline_with_suffix() {
 #[test]
 fn table_truncate_multiline() {
     let table = Matrix::new(3, 3)
-        .insert((1, 1), "H\nel\nlo World")
-        .insert((3, 2), "multi\nline string\n")
+        .insert((1, 1).into(), "H\nel\nlo World")
+        .insert((3, 2).into(), "multi\nline string\n")
         .with(Style::markdown())
         .with(Width::truncate(20).multiline(true))
         .to_string();
@@ -2420,8 +2422,8 @@ fn table_truncate_multiline() {
 #[test]
 fn table_truncate_multiline_with_suffix() {
     let table = Matrix::new(3, 3)
-        .insert((1, 1), "H\nel\nlo World")
-        .insert((3, 2), "multi\nline string\n")
+        .insert((1, 1).into(), "H\nel\nlo World")
+        .insert((3, 2).into(), "multi\nline string\n")
         .with(Style::markdown())
         .with(Width::truncate(20).suffix(".").multiline(true))
         .to_string();
@@ -2488,8 +2490,8 @@ test_table!(
 test_table!(
     priority_max_left,
     Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
-        .insert((2, 2), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
+        .insert((2, 2).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(37).priority(PriorityMax::left())),
     "| N | column  | column 1 | column 2 |"
@@ -2502,8 +2504,8 @@ test_table!(
 test_table!(
     priority_max_right,
     Matrix::new(3, 3)
-        .insert((2, 1), "Hello World With Big Line")
-        .insert((2, 2), "Hello World With Big Line")
+        .insert((2, 1).into(), "Hello World With Big Line")
+        .insert((2, 2).into(), "Hello World With Big Line")
         .with(Style::markdown())
         .with(Width::truncate(37).priority(PriorityMax::right())),
     "| N | column 0 | column 1 | column  |"