Repository: zhiburt/tabled
Pull request #374 (2023-11-21 23:56:37)

[WIP] rethinking Style compontents
ref: #369 


Patch:
diff --git a/papergrid/src/color/static_color.rs b/papergrid/src/color/static_color.rs
index 3f9a38c..a53eadc 100644
--- a/papergrid/src/color/static_color.rs
+++ b/papergrid/src/color/static_color.rs
@@ -3,7 +3,7 @@ use core::fmt::{self, Write};
 use super::Color;
 
 /// The structure represents a ANSI color by suffix and prefix.
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub struct StaticColor {
     prefix: &'static str,
     suffix: &'static str,
diff --git a/papergrid/src/config/border.rs b/papergrid/src/config/border.rs
index 0836bd5..c981807 100644
--- a/papergrid/src/config/border.rs
+++ b/papergrid/src/config/border.rs
@@ -35,6 +35,30 @@ pub struct Border<T> {
 }
 
 impl<T> Border<T> {
+    /// This function constructs a cell borders with all sides set.
+    #[allow(clippy::too_many_arguments)]
+    pub const fn new(
+        top: Option<T>,
+        bottom: Option<T>,
+        left: Option<T>,
+        right: Option<T>,
+        left_top_corner: Option<T>,
+        left_bottom_corner: Option<T>,
+        right_top_corner: Option<T>,
+        right_bottom_corner: Option<T>,
+    ) -> Self {
+        Self {
+            top,
+            bottom,
+            left,
+            right,
+            left_top_corner,
+            left_bottom_corner,
+            right_top_corner,
+            right_bottom_corner,
+        }
+    }
+
     /// This function constructs a cell borders with all sides set.
     #[allow(clippy::too_many_arguments)]
     pub const fn full(
@@ -47,30 +71,21 @@ impl<T> Border<T> {
         bottom_left: T,
         bottom_right: T,
     ) -> Self {
-        Self {
-            top: Some(top),
-            bottom: Some(bottom),
-            right: Some(right),
-            right_top_corner: Some(top_right),
-            right_bottom_corner: Some(bottom_right),
-            left: Some(left),
-            left_bottom_corner: Some(bottom_left),
-            left_top_corner: Some(top_left),
-        }
+        Self::new(
+            Some(top),
+            Some(bottom),
+            Some(left),
+            Some(right),
+            Some(top_left),
+            Some(bottom_left),
+            Some(top_right),
+            Some(bottom_right),
+        )
     }
 
     /// This function constructs a cell borders with all sides being empty (set off).
     pub const fn empty() -> Self {
-        Self {
-            top: None,
-            bottom: None,
-            right: None,
-            right_top_corner: None,
-            right_bottom_corner: None,
-            left: None,
-            left_bottom_corner: None,
-            left_top_corner: None,
-        }
+        Self::new(None, None, None, None, None, None, None, None)
     }
 
     /// Checks whether any side is set.
diff --git a/papergrid/src/config/compact/mod.rs b/papergrid/src/config/compact/mod.rs
index 099fa44..ff6b9b7 100644
--- a/papergrid/src/config/compact/mod.rs
+++ b/papergrid/src/config/compact/mod.rs
@@ -3,8 +3,7 @@
 //! [`CompactGrid`]: crate::grid::compact::CompactGrid
 
 use crate::color::StaticColor;
-
-use crate::config::{AlignmentHorizontal, Borders, Indent, Line, Sides};
+use crate::config::{AlignmentHorizontal, Borders, Indent, Sides};
 
 /// This structure represents a settings of a grid.
 ///
@@ -12,7 +11,6 @@ use crate::config::{AlignmentHorizontal, Borders, Indent, Line, Sides};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct CompactConfig {
     borders: Borders<char>,
-    horizontal_line1: Option<Line<char>>,
     border_colors: Borders<StaticColor>,
     margin: Sides<Indent>,
     margin_color: Sides<StaticColor>,
@@ -23,16 +21,15 @@ pub struct CompactConfig {
 
 impl Default for CompactConfig {
     fn default() -> Self {
-        Self::empty()
+        Self::new()
     }
 }
 
 impl CompactConfig {
     /// Returns an standard config.
-    pub const fn empty() -> Self {
+    pub const fn new() -> Self {
         Self {
             halignment: AlignmentHorizontal::Left,
-            horizontal_line1: None,
             borders: Borders::empty(),
             border_colors: Borders::empty(),
             margin: Sides::filled(Indent::zero()),
@@ -64,21 +61,6 @@ impl CompactConfig {
         self
     }
 
-    /// Set the first horizontal line.
-    ///
-    /// It ignores the [`Borders`] horizontal value if set for 1st row.
-    pub const fn set_first_horizontal_line(mut self, line: Line<char>) -> Self {
-        self.horizontal_line1 = Some(line);
-        self
-    }
-
-    /// Set the first horizontal line.
-    ///
-    /// It ignores the [`Borders`] horizontal value if set for 1st row.
-    pub const fn get_first_horizontal_line(&self) -> Option<Line<char>> {
-        self.horizontal_line1
-    }
-
     /// Returns a current [`Borders`] structure.
     pub const fn get_borders(&self) -> &Borders<char> {
         &self.borders
@@ -124,8 +106,8 @@ impl CompactConfig {
     }
 
     /// Returns a margin color.
-    pub const fn get_margin_color(&self) -> Sides<StaticColor> {
-        self.margin_color
+    pub const fn get_margin_color(&self) -> &Sides<StaticColor> {
+        &self.margin_color
     }
 
     /// Set a padding to a given cells.
@@ -135,7 +117,7 @@ impl CompactConfig {
     }
 
     /// Set a padding to a given cells.
-    pub const fn get_padding_color(&self) -> Sides<StaticColor> {
-        self.padding_color
+    pub const fn get_padding_color(&self) -> &Sides<StaticColor> {
+        &self.padding_color
     }
 }
diff --git a/papergrid/src/config/spanned/formatting.rs b/papergrid/src/config/formatting.rs
similarity index 78%
rename from papergrid/src/config/spanned/formatting.rs
rename to papergrid/src/config/formatting.rs
index 0865f6c..6ad6b6c 100644
--- a/papergrid/src/config/spanned/formatting.rs
+++ b/papergrid/src/config/formatting.rs
@@ -11,11 +11,11 @@ pub struct Formatting {
 
 impl Formatting {
     /// Creates a new [`Formatting`] structure.
-    pub fn new(horizontal_trim: bool, vertical_trim: bool, allow_lines_alignment: bool) -> Self {
+    pub const fn new(horizontal_trim: bool, vertical_trim: bool, lines_alignment: bool) -> Self {
         Self {
             horizontal_trim,
             vertical_trim,
-            allow_lines_alignment,
+            allow_lines_alignment: lines_alignment,
         }
     }
 }
diff --git a/papergrid/src/config/horizontal_line.rs b/papergrid/src/config/horizontal_line.rs
new file mode 100644
index 0000000..0701e9b
--- /dev/null
+++ b/papergrid/src/config/horizontal_line.rs
@@ -0,0 +1,60 @@
+/// A structure for a custom horizontal line.
+#[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct HorizontalLine<T> {
+    /// Line character.
+    pub main: Option<T>,
+    /// Line intersection character.
+    pub intersection: Option<T>,
+    /// Left intersection character.
+    pub left: Option<T>,
+    /// Right intersection character.
+    pub right: Option<T>,
+}
+
+impl<T> HorizontalLine<T> {
+    /// Creates a new line.
+    pub const fn new(
+        main: Option<T>,
+        intersection: Option<T>,
+        left: Option<T>,
+        right: Option<T>,
+    ) -> Self {
+        Self {
+            main,
+            intersection,
+            left,
+            right,
+        }
+    }
+
+    /// Creates a new line.
+    pub const fn full(main: T, intersection: T, left: T, right: T) -> Self {
+        Self::new(Some(main), Some(intersection), Some(left), Some(right))
+    }
+
+    /// Creates a new line.
+    pub const fn filled(val: T) -> Self
+    where
+        T: Copy,
+    {
+        Self {
+            main: Some(val),
+            intersection: Some(val),
+            left: Some(val),
+            right: Some(val),
+        }
+    }
+
+    /// Creates a new line.
+    pub const fn empty() -> Self {
+        Self::new(None, None, None, None)
+    }
+
+    /// Verifies if the line has any setting set.
+    pub const fn is_empty(&self) -> bool {
+        self.main.is_none()
+            && self.intersection.is_none()
+            && self.left.is_none()
+            && self.right.is_none()
+    }
+}
diff --git a/papergrid/src/config/line.rs b/papergrid/src/config/line.rs
deleted file mode 100644
index 4615332..0000000
--- a/papergrid/src/config/line.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-/// A line data structure.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Line<T> {
-    /// A horizontal/vertical character.
-    pub main: T,
-    /// A horizontal/vertical intersection.
-    pub intersection: Option<T>,
-    /// A horizontal left / vertical top intersection.
-    pub connect1: Option<T>,
-    /// A horizontal right / vertical bottom intersection.
-    pub connect2: Option<T>,
-}
-
-impl<T> Line<T> {
-    /// Creates a new line.
-    pub const fn new(
-        main: T,
-        intersection: Option<T>,
-        connect1: Option<T>,
-        connect2: Option<T>,
-    ) -> Self {
-        Self {
-            main,
-            intersection,
-            connect1,
-            connect2,
-        }
-    }
-
-    /// Creates a new line.
-    pub const fn filled(val: T) -> Self
-    where
-        T: Copy,
-    {
-        Self {
-            main: val,
-            intersection: Some(val),
-            connect1: Some(val),
-            connect2: Some(val),
-        }
-    }
-}
diff --git a/papergrid/src/config/mod.rs b/papergrid/src/config/mod.rs
index bba0b45..a7180cb 100644
--- a/papergrid/src/config/mod.rs
+++ b/papergrid/src/config/mod.rs
@@ -4,10 +4,12 @@ mod alignment;
 mod border;
 mod borders;
 mod entity;
+mod formatting;
+mod horizontal_line;
 mod indent;
-mod line;
 mod position;
 mod sides;
+mod vertical_line;
 
 pub mod compact;
 #[cfg(feature = "std")]
@@ -17,7 +19,9 @@ pub use alignment::{AlignmentHorizontal, AlignmentVertical};
 pub use border::Border;
 pub use borders::Borders;
 pub use entity::{Entity, EntityIterator};
+pub use formatting::Formatting;
+pub use horizontal_line::HorizontalLine;
 pub use indent::Indent;
-pub use line::Line;
 pub use position::Position;
 pub use sides::Sides;
+pub use vertical_line::VerticalLine;
diff --git a/papergrid/src/config/spanned/borders_config.rs b/papergrid/src/config/spanned/borders_config.rs
index fb61ed3..486e90c 100644
--- a/papergrid/src/config/spanned/borders_config.rs
+++ b/papergrid/src/config/spanned/borders_config.rs
@@ -1,6 +1,6 @@
 use std::collections::{HashMap, HashSet};
 
-use crate::config::{Border, Borders, Position};
+use crate::config::{Border, Borders, HorizontalLine, Position, VerticalLine};
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub(crate) struct BordersConfig<T> {
@@ -12,13 +12,25 @@ pub(crate) struct BordersConfig<T> {
     layout: BordersLayout,
 }
 
-impl<T> BordersConfig<T> {
-    pub(crate) fn insert_border(&mut self, pos: Position, border: Border<T>)
-    where
-        T: std::fmt::Debug,
-    {
-        dbg!("{:?}", &border);
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub(crate) struct BordersMap<T> {
+    vertical: HashMap<Position, T>,
+    horizontal: HashMap<Position, T>,
+    intersection: HashMap<Position, T>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub(crate) struct BordersLayout {
+    left: bool,
+    right: bool,
+    top: bool,
+    bottom: bool,
+    horizontals: HashSet<usize>,
+    verticals: HashSet<usize>,
+}
 
+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);
@@ -342,69 +354,6 @@ impl<T> BordersConfig<T> {
     }
 }
 
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub(crate) struct BordersMap<T> {
-    vertical: HashMap<Position, T>,
-    horizontal: HashMap<Position, T>,
-    intersection: HashMap<Position, T>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub(crate) struct BordersLayout {
-    left: bool,
-    right: bool,
-    top: bool,
-    bottom: bool,
-    horizontals: HashSet<usize>,
-    verticals: HashSet<usize>,
-}
-
-/// A structure for a custom horizontal line.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HorizontalLine<T> {
-    /// Line character.
-    pub main: Option<T>,
-    /// Line intersection character.
-    pub intersection: Option<T>,
-    /// Left intersection character.
-    pub left: Option<T>,
-    /// Right intersection character.
-    pub right: Option<T>,
-}
-
-impl<T> HorizontalLine<T> {
-    /// Verifies if the line has any setting set.
-    pub const fn is_empty(&self) -> bool {
-        self.main.is_none()
-            && self.intersection.is_none()
-            && self.left.is_none()
-            && self.right.is_none()
-    }
-}
-
-/// A structure for a vertical line.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
-pub struct VerticalLine<T> {
-    /// Line character.
-    pub main: Option<T>,
-    /// Line intersection character.
-    pub intersection: Option<T>,
-    /// Left intersection character.
-    pub top: Option<T>,
-    /// Right intersection character.
-    pub bottom: Option<T>,
-}
-
-impl<T> VerticalLine<T> {
-    /// Verifies if the line has any setting set.
-    pub const fn is_empty(&self) -> bool {
-        self.main.is_none()
-            && self.intersection.is_none()
-            && self.top.is_none()
-            && self.bottom.is_none()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/papergrid/src/config/spanned/mod.rs b/papergrid/src/config/spanned/mod.rs
index 66b1d44..c8a538a 100644
--- a/papergrid/src/config/spanned/mod.rs
+++ b/papergrid/src/config/spanned/mod.rs
@@ -4,19 +4,25 @@
 
 mod borders_config;
 mod entity_map;
-mod formatting;
 mod offset;
 
 use std::collections::HashMap;
 
 use crate::color::{AnsiColor, StaticColor};
 use crate::config::compact::CompactConfig;
+use crate::config::Formatting;
 use crate::config::{
     AlignmentHorizontal, AlignmentVertical, Border, Borders, Entity, Indent, Position, Sides,
 };
 use borders_config::BordersConfig;
 
-pub use self::{entity_map::EntityMap, formatting::Formatting, offset::Offset};
+pub use self::{entity_map::EntityMap, offset::Offset};
+
+/// HorizontalLine represents a horizontal border line.
+type HorizontalLine = super::HorizontalLine<char>;
+
+/// VerticalLine represents a vertical border line.
+type VerticalLine = super::VerticalLine<char>;
 
 /// This structure represents a settings of a grid.
 ///
@@ -756,27 +762,15 @@ impl From<CompactConfig> for SpannedConfig {
         let mut cfg = Self::default();
 
         cfg.set_padding(Global, *compact.get_padding());
-        cfg.set_padding_color(Global, to_ansi_color(compact.get_padding_color()));
+        cfg.set_padding_color(Global, to_ansi_color(*compact.get_padding_color()));
         cfg.set_margin(*compact.get_margin());
-        cfg.set_margin_color(to_ansi_color(compact.get_margin_color()));
+        cfg.set_margin_color(to_ansi_color(*compact.get_margin_color()));
         cfg.set_alignment_horizontal(Global, compact.get_alignment_horizontal());
         cfg.set_borders(*compact.get_borders());
         cfg.set_borders_color(borders_static_color_to_ansi_color(
             *compact.get_borders_color(),
         ));
 
-        if let Some(line) = compact.get_first_horizontal_line() {
-            cfg.insert_horizontal_line(
-                1,
-                HorizontalLine {
-                    intersection: line.intersection,
-                    left: line.connect1,
-                    right: line.connect2,
-                    main: Some(line.main),
-                },
-            );
-        }
-
         cfg
     }
 }
@@ -895,9 +889,3 @@ impl Default for ColoredMarginIndent {
         }
     }
 }
-
-/// HorizontalLine represents a horizontal border line.
-pub type HorizontalLine = borders_config::HorizontalLine<char>;
-
-/// HorizontalLine represents a vertical border line.
-pub type VerticalLine = borders_config::VerticalLine<char>;
diff --git a/papergrid/src/config/vertical_line.rs b/papergrid/src/config/vertical_line.rs
new file mode 100644
index 0000000..2dfeba6
--- /dev/null
+++ b/papergrid/src/config/vertical_line.rs
@@ -0,0 +1,60 @@
+/// A structure for a vertical line.
+#[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct VerticalLine<T> {
+    /// Line character.
+    pub main: Option<T>,
+    /// Line intersection character.
+    pub intersection: Option<T>,
+    /// Left intersection character.
+    pub top: Option<T>,
+    /// Right intersection character.
+    pub bottom: Option<T>,
+}
+
+impl<T> VerticalLine<T> {
+    /// Creates a new line.
+    pub const fn new(
+        main: Option<T>,
+        intersection: Option<T>,
+        top: Option<T>,
+        bottom: Option<T>,
+    ) -> Self {
+        Self {
+            main,
+            intersection,
+            top,
+            bottom,
+        }
+    }
+
+    /// Creates a new line.
+    pub const fn full(main: T, intersection: T, left: T, right: T) -> Self {
+        Self::new(Some(main), Some(intersection), Some(left), Some(right))
+    }
+
+    /// Creates a new line.
+    pub const fn filled(val: T) -> Self
+    where
+        T: Copy,
+    {
+        Self {
+            main: Some(val),
+            intersection: Some(val),
+            top: Some(val),
+            bottom: Some(val),
+        }
+    }
+
+    /// Creates a new line.
+    pub const fn empty() -> Self {
+        Self::new(None, None, None, None)
+    }
+
+    /// Verifies if the line has any setting set.
+    pub const fn is_empty(&self) -> bool {
+        self.main.is_none()
+            && self.intersection.is_none()
+            && self.top.is_none()
+            && self.bottom.is_none()
+    }
+}
diff --git a/papergrid/src/grid/compact.rs b/papergrid/src/grid/compact.rs
index cdf16f8..2de2c7b 100644
--- a/papergrid/src/grid/compact.rs
+++ b/papergrid/src/grid/compact.rs
@@ -9,7 +9,7 @@ use core::{
 use crate::{
     color::{Color, StaticColor},
     colors::{Colors, NoColors},
-    config::{AlignmentHorizontal, Borders, Indent, Line, Sides},
+    config::{AlignmentHorizontal, Borders, HorizontalLine, Indent, Sides},
     dimension::Dimension,
     records::Records,
     util::string::string_width,
@@ -99,13 +99,19 @@ where
     }
 }
 
-fn print_grid<F: Write, R: Records, D: Dimension, C: Colors>(
+fn print_grid<F, R, D, C>(
     f: &mut F,
     records: R,
     cfg: &CompactConfig,
     dims: &D,
     colors: &C,
-) -> fmt::Result {
+) -> fmt::Result
+where
+    F: Write,
+    R: Records,
+    D: Dimension,
+    C: Colors,
+{
     let count_columns = records.count_columns();
     let count_rows = records.hint_count_rows();
 
@@ -114,192 +120,239 @@ fn print_grid<F: Write, R: Records, D: Dimension, C: Colors>(
     }
 
     let mut records = records.iter_rows().into_iter();
-    let mut next_columns = records.next();
-
-    if next_columns.is_none() {
-        return Ok(());
-    }
+    let records_first = match records.next() {
+        Some(row) => row,
+        None => return Ok(()),
+    };
 
     let wtotal = total_width(cfg, dims, count_columns);
 
-    let borders = cfg.get_borders();
-    let bcolors = cfg.get_borders_color();
+    let borders_chars = cfg.get_borders();
+    let borders_colors = cfg.get_borders_color();
 
-    let h_chars = create_horizontal(borders);
-    let h_colors = create_horizontal_colors(bcolors);
+    let horizontal_borders = create_horizontal(borders_chars);
+    let horizontal_colors = create_horizontal_colors(borders_colors);
 
-    let has_horizontal = borders.has_horizontal();
-    let has_horizontal_colors = bcolors.has_horizontal();
-    let has_horizontal_second = cfg.get_first_horizontal_line().is_some();
+    let vertical_borders = create_vertical_borders(borders_chars, borders_colors);
 
-    let vert = (
-        borders.left.map(|c| (c, bcolors.left)),
-        borders.vertical.map(|c| (c, bcolors.vertical)),
-        borders.right.map(|c| (c, bcolors.right)),
-    );
-
-    let margin = cfg.get_margin();
-    let margin_color = cfg.get_margin_color();
-    let pad = create_padding(cfg);
-    let align = cfg.get_alignment_horizontal();
-    let mar = (
-        (margin.left, margin_color.left),
-        (margin.right, margin_color.right),
-    );
-
-    let widths = (0..count_columns).map(|col| dims.get_width(col));
+    let margin = create_margin(cfg);
+    let padding = create_padding(cfg);
+    let alignment = cfg.get_alignment_horizontal();
 
     let mut new_line = false;
 
-    if margin.top.size > 0 {
-        let wtotal = wtotal + margin.left.size + margin.right.size;
-        print_indent_lines(f, wtotal, margin.top, margin_color.top)?;
+    if margin.top.space.size > 0 {
+        let width_total = wtotal + margin.left.space.size + margin.right.space.size;
+        let indent = ColoredIndent::new(width_total, margin.top.space.fill, margin.top.color);
+        print_indent_lines(f, indent)?;
         new_line = true;
     }
 
-    if borders.has_top() {
+    if borders_chars.has_top() {
         if new_line {
             f.write_char('\n')?
         }
 
-        print_indent2(f, margin.left, margin_color.left)?;
-
-        let chars = create_horizontal_top(borders);
-        if bcolors.has_top() {
-            let chars_color = create_horizontal_top_colors(bcolors);
-            print_split_line_colored(f, chars, chars_color, dims, count_columns)?;
-        } else {
-            print_split_line(f, chars, dims, count_columns)?;
-        }
-
-        print_indent2(f, margin.right, margin_color.right)?;
+        let borders = create_horizontal_top(borders_chars);
+        let borders_colors = create_horizontal_top_colors(borders_colors);
+        print_horizontal_line(f, dims, &borders, &borders_colors, &margin, count_columns)?;
 
         new_line = true;
     }
 
-    let mut row = 0;
-    while let Some(columns) = next_columns {
-        let columns = columns.into_iter();
-        next_columns = records.next();
-
-        if row > 0 && has_horizontal {
-            if new_line {
-                f.write_char('\n')?;
-            }
-
-            print_indent2(f, margin.left, margin_color.left)?;
-
-            if has_horizontal_colors {
-                print_split_line_colored(f, h_chars, h_colors, dims, count_columns)?;
-            } else {
-                print_split_line(f, h_chars, dims, count_columns)?;
-            }
-
-            print_indent2(f, margin.right, margin_color.right)?;
-        } else if row == 1 && has_horizontal_second {
-            if new_line {
-                f.write_char('\n')?;
-            }
+    if borders_chars.has_horizontal() {
+        if new_line {
+            f.write_char('\n')?;
+        }
 
-            print_indent2(f, margin.left, margin_color.left)?;
+        let cells = records_first.into_iter();
+        print_grid_row(
+            f,
+            cells,
+            count_columns,
+            dims,
+            colors,
+            &margin,
+            &padding,
+            &vertical_borders,
+            alignment,
+            0,
+        )?;
+
+        for (row, cells) in records.enumerate() {
+            f.write_char('\n')?;
 
-            let h_chars = cfg.get_first_horizontal_line().expect("must be here");
+            print_horizontal_line(
+                f,
+                dims,
+                &horizontal_borders,
+                &horizontal_colors,
+                &margin,
+                count_columns,
+            )?;
 
-            if has_horizontal_colors {
-                print_split_line_colored(f, h_chars, h_colors, dims, count_columns)?;
-            } else {
-                print_split_line(f, h_chars, dims, count_columns)?;
-            }
+            f.write_char('\n')?;
 
-            print_indent2(f, margin.right, margin_color.right)?;
+            let cells = cells.into_iter();
+            print_grid_row(
+                f,
+                cells,
+                count_columns,
+                dims,
+                colors,
+                &margin,
+                &padding,
+                &vertical_borders,
+                alignment,
+                row + 1,
+            )?;
         }
-
+    } else {
         if new_line {
             f.write_char('\n')?;
         }
 
-        let columns = columns
-            .enumerate()
-            .map(|(col, text)| (text, colors.get_color((row, col))));
-
-        let widths = widths.clone();
-        print_grid_row(f, columns, widths, mar, pad, vert, align)?;
+        print_grid_row(
+            f,
+            records_first.into_iter(),
+            count_columns,
+            dims,
+            colors,
+            &margin,
+            &padding,
+            &vertical_borders,
+            alignment,
+            0,
+        )?;
+
+        for (row, cells) in records.enumerate() {
+            f.write_char('\n')?;
 
-        new_line = true;
-        row += 1;
+            print_grid_row(
+                f,
+                cells.into_iter(),
+                count_columns,
+                dims,
+                colors,
+                &margin,
+                &padding,
+                &vertical_borders,
+                alignment,
+                row + 1,
+            )?;
+        }
     }
 
-    if borders.has_bottom() {
+    if borders_chars.has_bottom() {
         f.write_char('\n')?;
 
-        print_indent2(f, margin.left, margin_color.left)?;
-
-        let chars = create_horizontal_bottom(borders);
-        if bcolors.has_bottom() {
-            let chars_color = create_horizontal_bottom_colors(bcolors);
-            print_split_line_colored(f, chars, chars_color, dims, count_columns)?;
-        } else {
-            print_split_line(f, chars, dims, count_columns)?;
-        }
-
-        print_indent2(f, margin.right, margin_color.right)?;
+        let borders = create_horizontal_bottom(borders_chars);
+        let colors = create_horizontal_bottom_colors(borders_colors);
+        print_horizontal_line(f, dims, &borders, &colors, &margin, count_columns)?;
     }
 
     if cfg.get_margin().bottom.size > 0 {
         f.write_char('\n')?;
 
-        let wtotal = wtotal + margin.left.size + margin.right.size;
-        print_indent_lines(f, wtotal, margin.bottom, margin_color.bottom)?;
+        let width_total = wtotal + margin.left.space.size + margin.right.space.size;
+        let indent = ColoredIndent::new(width_total, margin.bottom.space.fill, margin.bottom.color);
+        print_indent_lines(f, indent)?;
     }
 
     Ok(())
 }
 
-type ColoredIndent = (Indent, StaticColor);
+fn create_margin(cfg: &CompactConfig) -> Sides<ColoredIndent> {
+    let margin = cfg.get_margin();
+    let margin_color = cfg.get_margin_color();
+    Sides::new(
+        ColoredIndent::from_indent(margin.left, margin_color.left),
+        ColoredIndent::from_indent(margin.right, margin_color.right),
+        ColoredIndent::from_indent(margin.top, margin_color.top),
+        ColoredIndent::from_indent(margin.bottom, margin_color.bottom),
+    )
+}
+
+fn create_vertical_borders(
+    borders: &Borders<char>,
+    colors: &Borders<StaticColor>,
+) -> HorizontalLine<ColoredIndent> {
+    let intersect = borders
+        .vertical
+        .map(|c| ColoredIndent::new(0, c, colors.vertical));
+    let left = borders.left.map(|c| ColoredIndent::new(0, c, colors.left));
+    let right = borders
+        .right
+        .map(|c| ColoredIndent::new(0, c, colors.right));
+
+    HorizontalLine::new(None, intersect, left, right)
+}
+
+fn print_horizontal_line<F, D>(
+    f: &mut F,
+    dims: &D,
+    borders: &HorizontalLine<char>,
+    borders_colors: &HorizontalLine<StaticColor>,
+    margin: &Sides<ColoredIndent>,
+    count_columns: usize,
+) -> fmt::Result
+where
+    F: fmt::Write,
+    D: Dimension,
+{
+    let is_not_colored = borders_colors.is_empty();
+
+    print_indent(f, margin.left)?;
+
+    if is_not_colored {
+        print_split_line(f, dims, borders, count_columns)?;
+    } else {
+        print_split_line_colored(f, dims, borders, borders_colors, count_columns)?;
+    }
+
+    print_indent(f, margin.right)?;
+
+    Ok(())
+}
 
 #[allow(clippy::too_many_arguments)]
 fn print_grid_row<F, I, T, C, D>(
     f: &mut F,
-    columns: I,
-    widths: D,
-    mar: (ColoredIndent, ColoredIndent),
-    pad: Sides<ColoredIndent>,
-    vert: (BorderChar, BorderChar, BorderChar),
-    align: AlignmentHorizontal,
+    data: I,
+    size: usize,
+    dims: &D,
+    colors: &C,
+    margin: &Sides<ColoredIndent>,
+    padding: &Sides<ColoredIndent>,
+    borders: &HorizontalLine<ColoredIndent>,
+    alignemnt: AlignmentHorizontal,
+    row: usize,
 ) -> fmt::Result
 where
     F: Write,
-    I: Iterator<Item = (T, Option<C>)>,
+    I: Iterator<Item = T>,
     T: AsRef<str>,
-    C: Color,
-    D: Iterator<Item = usize> + Clone,
+    C: Colors,
+    D: Dimension,
 {
-    if pad.top.0.size > 0 {
-        for _ in 0..pad.top.0.size {
-            print_indent2(f, mar.0 .0, mar.0 .1)?;
-            print_columns_empty_colored(f, widths.clone(), vert, pad.top.1)?;
-            print_indent2(f, mar.1 .0, mar.1 .1)?;
+    for _ in 0..padding.top.space.size {
+        print_indent(f, margin.left)?;
+        print_columns_empty_colored(f, dims, borders, padding.top.color, size)?;
+        print_indent(f, margin.right)?;
 
-            f.write_char('\n')?;
-        }
+        f.write_char('\n')?;
     }
 
-    let mut widths1 = widths.clone();
-    let columns = columns.map(move |(text, color)| {
-        let width = widths1.next().expect("must be here");
-        (text, color, width)
-    });
-
-    print_indent2(f, mar.0 .0, mar.0 .1)?;
-    print_row_columns(f, columns, vert, pad, align)?;
-    print_indent2(f, mar.1 .0, mar.1 .1)?;
+    print_indent(f, margin.left)?;
+    print_row_columns_one_line(f, data, dims, colors, borders, padding, alignemnt, row)?;
+    print_indent(f, margin.right)?;
 
-    for _ in 0..pad.bottom.0.size {
+    for _ in 0..padding.top.space.size {
         f.write_char('\n')?;
 
-        print_indent2(f, mar.0 .0, mar.0 .1)?;
-        print_columns_empty_colored(f, widths.clone(), vert, pad.bottom.1)?;
-        print_indent2(f, mar.1 .0, mar.1 .1)?;
+        print_indent(f, margin.left)?;
+        print_columns_empty_colored(f, dims, borders, padding.bottom.color, size)?;
+        print_indent(f, margin.right)?;
     }
 
     Ok(())
@@ -307,78 +360,67 @@ where
 
 fn create_padding(cfg: &CompactConfig) -> Sides<ColoredIndent> {
     let pad = cfg.get_padding();
-    let pad_colors = cfg.get_padding_color();
+    let colors = cfg.get_padding_color();
     Sides::new(
-        (pad.left, pad_colors.left),
-        (pad.right, pad_colors.right),
-        (pad.top, pad_colors.top),
-        (pad.bottom, pad_colors.bottom),
+        ColoredIndent::new(pad.left.size, pad.left.fill, create_color(colors.left)),
+        ColoredIndent::new(pad.right.size, pad.right.fill, create_color(colors.right)),
+        ColoredIndent::new(pad.top.size, pad.top.fill, create_color(colors.top)),
+        ColoredIndent::new(
+            pad.bottom.size,
+            pad.bottom.fill,
+            create_color(colors.bottom),
+        ),
     )
 }
 
-fn create_horizontal(b: &Borders<char>) -> Line<char> {
-    Line::new(b.horizontal.unwrap_or(' '), b.intersection, b.left, b.right)
+fn create_horizontal(b: &Borders<char>) -> HorizontalLine<char> {
+    HorizontalLine::new(b.horizontal, b.intersection, b.left, b.right)
 }
 
-fn create_horizontal_top(b: &Borders<char>) -> Line<char> {
-    Line::new(
-        b.top.unwrap_or(' '),
-        b.top_intersection,
-        b.top_left,
-        b.top_right,
-    )
+fn create_horizontal_top(b: &Borders<char>) -> HorizontalLine<char> {
+    HorizontalLine::new(b.top, b.top_intersection, b.top_left, b.top_right)
 }
 
-fn create_horizontal_bottom(b: &Borders<char>) -> Line<char> {
-    Line::new(
-        b.bottom.unwrap_or(' '),
+fn create_horizontal_bottom(b: &Borders<char>) -> HorizontalLine<char> {
+    HorizontalLine::new(
+        b.bottom,
         b.bottom_intersection,
         b.bottom_left,
         b.bottom_right,
     )
 }
 
-fn create_horizontal_colors(
-    b: &Borders<StaticColor>,
-) -> (StaticColor, StaticColor, StaticColor, StaticColor) {
-    (
-        b.horizontal.unwrap_or_default(),
-        b.left.unwrap_or_default(),
-        b.intersection.unwrap_or_default(),
-        b.right.unwrap_or_default(),
-    )
+fn create_horizontal_colors(b: &Borders<StaticColor>) -> HorizontalLine<StaticColor> {
+    HorizontalLine::new(b.horizontal, b.intersection, b.left, b.right)
 }
 
-fn create_horizontal_top_colors(
-    b: &Borders<StaticColor>,
-) -> (StaticColor, StaticColor, StaticColor, StaticColor) {
-    (
-        b.top.unwrap_or_default(),
-        b.top_left.unwrap_or_default(),
-        b.top_intersection.unwrap_or_default(),
-        b.top_right.unwrap_or_default(),
-    )
+fn create_horizontal_top_colors(b: &Borders<StaticColor>) -> HorizontalLine<StaticColor> {
+    HorizontalLine::new(b.top, b.top_intersection, b.top_left, b.top_right)
 }
 
-fn create_horizontal_bottom_colors(
-    b: &Borders<StaticColor>,
-) -> (StaticColor, StaticColor, StaticColor, StaticColor) {
-    (
-        b.bottom.unwrap_or_default(),
-        b.bottom_left.unwrap_or_default(),
-        b.bottom_intersection.unwrap_or_default(),
-        b.bottom_right.unwrap_or_default(),
+fn create_horizontal_bottom_colors(b: &Borders<StaticColor>) -> HorizontalLine<StaticColor> {
+    HorizontalLine::new(
+        b.bottom,
+        b.bottom_intersection,
+        b.bottom_left,
+        b.bottom_right,
     )
 }
 
-fn total_width<D: Dimension>(cfg: &CompactConfig, dims: &D, count_columns: usize) -> usize {
+fn total_width<D>(cfg: &CompactConfig, dims: &D, count_columns: usize) -> usize
+where
+    D: Dimension,
+{
     let content_width = total_columns_width(count_columns, dims);
     let count_verticals = count_verticals(cfg, count_columns);
 
     content_width + count_verticals
 }
 
-fn total_columns_width<D: Dimension>(count_columns: usize, dims: &D) -> usize {
+fn total_columns_width<D>(count_columns: usize, dims: &D) -> usize
+where
+    D: Dimension,
+{
     (0..count_columns).map(|i| dims.get_width(i)).sum::<usize>()
 }
 
@@ -392,146 +434,203 @@ fn count_verticals(cfg: &CompactConfig, count_columns: usize) -> usize {
         + borders.has_right() as usize
 }
 
-type BorderChar = Option<(char, Option<StaticColor>)>;
-
-fn print_row_columns<F, I, T, C>(
+#[allow(clippy::too_many_arguments)]
+fn print_row_columns_one_line<F, I, T, D, C>(
     f: &mut F,
-    mut columns: I,
-    borders: (BorderChar, BorderChar, BorderChar),
-    pad: Sides<ColoredIndent>,
-    align: AlignmentHorizontal,
-) -> Result<(), fmt::Error>
+    mut data: I,
+    dims: &D,
+    colors: &C,
+    borders: &HorizontalLine<ColoredIndent>,
+    padding: &Sides<ColoredIndent>,
+    alignement: AlignmentHorizontal,
+    row: usize,
+) -> fmt::Result
 where
     F: Write,
-    I: Iterator<Item = (T, Option<C>, usize)>,
+    I: Iterator<Item = T>,
     T: AsRef<str>,
-    C: Color,
+    D: Dimension,
+    C: Colors,
 {
-    if let Some((c, color)) = borders.0 {
-        print_char(f, c, color)?;
+    if let Some(indent) = borders.left {
+        print_char(f, indent.space.fill, indent.color)?;
     }
 
-    if let Some((text, color, width)) = columns.next() {
-        let text = text.as_ref();
-        let text = text.lines().next().unwrap_or("");
-        print_cell(f, text, width, color, (pad.left, pad.right), align)?;
-    }
+    let text = data
+        .next()
+        .expect("we check in the beggining that size must be at least 1 column");
+    let width = dims.get_width(0);
+    let color = colors.get_color((row, 0));
+
+    let text = text.as_ref();
+    let text = text.lines().next().unwrap_or("");
+    print_cell(f, text, color, padding, alignement, width)?;
+
+    match borders.intersection {
+        Some(indent) => {
+            for (col, text) in data.enumerate() {
+                let col = col + 1;
+
+                let width = dims.get_width(col);
+                let color = colors.get_color((row, col));
+                let text = text.as_ref();
+                let text = text.lines().next().unwrap_or("");
 
-    for (text, color, width) in columns {
-        if let Some((c, color)) = borders.1 {
-            print_char(f, c, color)?;
+                print_char(f, indent.space.fill, indent.color)?;
+                print_cell(f, text, color, padding, alignement, width)?;
+            }
         }
+        None => {
+            for (col, text) in data.enumerate() {
+                let col = col + 1;
+
+                let width = dims.get_width(col);
+                let color = colors.get_color((row, col));
+                let text = text.as_ref();
+                let text = text.lines().next().unwrap_or("");
 
-        let text = text.as_ref();
-        let text = text.lines().next().unwrap_or("");
-        print_cell(f, text, width, color, (pad.left, pad.right), align)?;
+                print_cell(f, text, color, padding, alignement, width)?;
+            }
+        }
     }
 
-    if let Some((c, color)) = borders.2 {
-        print_char(f, c, color)?;
+    if let Some(indent) = borders.right {
+        print_char(f, indent.space.fill, indent.color)?;
     }
 
     Ok(())
 }
 
-fn print_columns_empty_colored<F: Write, I: Iterator<Item = usize>>(
+fn print_columns_empty_colored<F, D>(
     f: &mut F,
-    mut columns: I,
-    borders: (BorderChar, BorderChar, BorderChar),
-    color: StaticColor,
-) -> Result<(), fmt::Error> {
-    if let Some((c, color)) = borders.0 {
-        print_char(f, c, color)?;
+    dims: &D,
+    borders: &HorizontalLine<ColoredIndent>,
+    color: Option<StaticColor>,
+    count_columns: usize,
+) -> fmt::Result
+where
+    F: Write,
+    D: Dimension,
+{
+    if let Some(indent) = borders.left {
+        print_char(f, indent.space.fill, indent.color)?;
     }
 
-    if let Some(width) = columns.next() {
-        color.fmt_prefix(f)?;
-        repeat_char(f, ' ', width)?;
-        color.fmt_suffix(f)?;
-    }
+    let width = dims.get_width(0);
+    print_indent(f, ColoredIndent::new(width, ' ', color))?;
 
-    for width in columns {
-        if let Some((c, color)) = borders.1 {
-            print_char(f, c, color)?;
-        }
+    match borders.intersection {
+        Some(indent) => {
+            for column in 1..count_columns {
+                let width = dims.get_width(column);
 
-        color.fmt_prefix(f)?;
-        repeat_char(f, ' ', width)?;
-        color.fmt_suffix(f)?;
+                print_char(f, indent.space.fill, indent.color)?;
+                print_indent(f, ColoredIndent::new(width, ' ', color))?;
+            }
+        }
+        None => {
+            for column in 1..count_columns {
+                let width = dims.get_width(column);
+                print_indent(f, ColoredIndent::new(width, ' ', color))?;
+            }
+        }
     }
 
-    if let Some((c, color)) = borders.2 {
-        print_char(f, c, color)?;
+    if let Some(indent) = borders.right {
+        print_char(f, indent.space.fill, indent.color)?;
     }
 
     Ok(())
 }
 
-fn print_cell<F: Write, C: Color>(
+fn print_cell<F, C>(
     f: &mut F,
     text: &str,
-    width: usize,
     color: Option<C>,
-    (pad_l, pad_r): (ColoredIndent, ColoredIndent),
-    align: AlignmentHorizontal,
-) -> fmt::Result {
-    let available = width - pad_l.0.size - pad_r.0.size;
+    padding: &Sides<ColoredIndent>,
+    alignment: AlignmentHorizontal,
+    width: usize,
+) -> fmt::Result
+where
+    F: Write,
+    C: Color,
+{
+    let available = width - (padding.left.space.size + padding.right.space.size);
 
     let text_width = string_width(text);
-    let (left, right) = if available < text_width {
-        (0, 0)
+    let (left, right) = if available > text_width {
+        calculate_indent(alignment, text_width, available)
     } else {
-        calculate_indent(align, text_width, available)
+        (0, 0)
     };
 
-    print_indent(f, pad_l.0.fill, pad_l.0.size, pad_l.1)?;
+    print_indent(f, padding.left)?;
 
     repeat_char(f, ' ', left)?;
     print_text(f, text, color)?;
     repeat_char(f, ' ', right)?;
 
-    print_indent(f, pad_r.0.fill, pad_r.0.size, pad_r.1)?;
+    print_indent(f, padding.right)?;
 
     Ok(())
 }
 
-fn print_split_line_colored<F: Write>(
+fn print_split_line_colored<F, D>(
     f: &mut F,
-    chars: Line<char>,
-    colors: (StaticColor, StaticColor, StaticColor, StaticColor),
-    dimension: impl Dimension,
+    dimension: &D,
+    borders: &HorizontalLine<char>,
+    borders_colors: &HorizontalLine<StaticColor>,
     count_columns: usize,
-) -> fmt::Result {
+) -> fmt::Result
+where
+    F: Write,
+    D: Dimension,
+{
     let mut used_color = StaticColor::default();
+    let chars_main = borders.main.unwrap_or(' ');
+
+    if let Some(c) = borders.left {
+        if let Some(color) = &borders_colors.right {
+            prepare_coloring(f, color, &mut used_color)?;
+        }
 
-    if let Some(c) = chars.connect1 {
-        colors.1.fmt_prefix(f)?;
         f.write_char(c)?;
-        used_color = colors.1;
     }
 
     let width = dimension.get_width(0);
     if width > 0 {
-        prepare_coloring(f, &colors.0, &mut used_color)?;
-        repeat_char(f, chars.main, width)?;
+        if let Some(color) = borders_colors.main {
+            prepare_coloring(f, &color, &mut used_color)?;
+        }
+
+        repeat_char(f, chars_main, width)?;
     }
 
     for col in 1..count_columns {
-        if let Some(c) = &chars.intersection {
-            prepare_coloring(f, &colors.2, &mut used_color)?;
-            f.write_char(*c)?;
+        if let Some(c) = borders.intersection {
+            if let Some(color) = borders_colors.intersection {
+                prepare_coloring(f, &color, &mut used_color)?;
+            }
+
+            f.write_char(c)?;
         }
 
         let width = dimension.get_width(col);
         if width > 0 {
-            prepare_coloring(f, &colors.0, &mut used_color)?;
-            repeat_char(f, chars.main, width)?;
+            if let Some(color) = borders_colors.main {
+                prepare_coloring(f, &color, &mut used_color)?;
+            }
+
+            repeat_char(f, chars_main, width)?;
         }
     }
 
-    if let Some(c) = &chars.connect2 {
-        prepare_coloring(f, &colors.3, &mut used_color)?;
-        f.write_char(*c)?;
+    if let Some(c) = borders.right {
+        if let Some(color) = &borders_colors.right {
+            prepare_coloring(f, color, &mut used_color)?;
+        }
+
+        f.write_char(c)?;
     }
 
     used_color.fmt_suffix(f)?;
@@ -539,19 +638,25 @@ fn print_split_line_colored<F: Write>(
     Ok(())
 }
 
-fn print_split_line<F: Write>(
+fn print_split_line<F, D>(
     f: &mut F,
-    chars: Line<char>,
-    dimension: impl Dimension,
+    dims: &D,
+    chars: &HorizontalLine<char>,
     count_columns: usize,
-) -> fmt::Result {
-    if let Some(c) = chars.connect1 {
+) -> fmt::Result
+where
+    F: Write,
+    D: Dimension,
+{
+    let chars_main = chars.main.unwrap_or(' ');
+
+    if let Some(c) = chars.left {
         f.write_char(c)?;
     }
 
-    let width = dimension.get_width(0);
+    let width = dims.get_width(0);
     if width > 0 {
-        repeat_char(f, chars.main, width)?;
+        repeat_char(f, chars_main, width)?;
     }
 
     for col in 1..count_columns {
@@ -559,31 +664,42 @@ fn print_split_line<F: Write>(
             f.write_char(c)?;
         }
 
-        let width = dimension.get_width(col);
+        let width = dims.get_width(col);
         if width > 0 {
-            repeat_char(f, chars.main, width)?;
+            repeat_char(f, chars_main, width)?;
         }
     }
 
-    if let Some(c) = chars.connect2 {
+    if let Some(c) = chars.right {
         f.write_char(c)?;
     }
 
     Ok(())
 }
 
-fn print_text<F: Write>(f: &mut F, text: &str, clr: Option<impl Color>) -> fmt::Result {
-    match clr {
+fn print_text<F, C>(f: &mut F, text: &str, color: Option<C>) -> fmt::Result
+where
+    F: Write,
+    C: Color,
+{
+    match color {
         Some(color) => {
             color.fmt_prefix(f)?;
             f.write_str(text)?;
-            color.fmt_suffix(f)
+            color.fmt_suffix(f)?;
         }
-        None => f.write_str(text),
-    }
+        None => {
+            f.write_str(text)?;
+        }
+    };
+
+    Ok(())
 }
 
-fn prepare_coloring<F: Write>(f: &mut F, clr: &StaticColor, used: &mut StaticColor) -> fmt::Result {
+fn prepare_coloring<F>(f: &mut F, clr: &StaticColor, used: &mut StaticColor) -> fmt::Result
+where
+    F: Write,
+{
     if *used != *clr {
         used.fmt_suffix(f)?;
         clr.fmt_prefix(f)?;
@@ -610,7 +726,10 @@ fn calculate_indent(
     }
 }
 
-fn repeat_char<F: Write>(f: &mut F, c: char, n: usize) -> fmt::Result {
+fn repeat_char<F>(f: &mut F, c: char, n: usize) -> fmt::Result
+where
+    F: Write,
+{
     for _ in 0..n {
         f.write_char(c)?;
     }
@@ -618,7 +737,11 @@ fn repeat_char<F: Write>(f: &mut F, c: char, n: usize) -> fmt::Result {
     Ok(())
 }
 
-fn print_char<F: Write>(f: &mut F, c: char, color: Option<StaticColor>) -> fmt::Result {
+// todo: replace Option<StaticColor> to StaticColor and check performance
+fn print_char<F>(f: &mut F, c: char, color: Option<StaticColor>) -> fmt::Result
+where
+    F: Write,
+{
     match color {
         Some(color) => {
             color.fmt_prefix(f)?;
@@ -629,31 +752,65 @@ fn print_char<F: Write>(f: &mut F, c: char, color: Option<StaticColor>) -> fmt::
     }
 }
 
-fn print_indent_lines<F: Write>(
-    f: &mut F,
-    width: usize,
-    indent: Indent,
-    color: StaticColor,
-) -> fmt::Result {
-    print_indent(f, indent.fill, width, color)?;
+fn print_indent_lines<F>(f: &mut F, indent: ColoredIndent) -> fmt::Result
+where
+    F: Write,
+{
+    print_indent(f, indent)?;
     f.write_char('\n')?;
 
-    for _ in 1..indent.size {
+    for _ in 1..indent.space.size {
         f.write_char('\n')?;
-        print_indent(f, indent.fill, width, color)?;
+        print_indent(f, indent)?;
     }
 
     Ok(())
 }
 
-fn print_indent<F: Write>(f: &mut F, c: char, n: usize, color: StaticColor) -> fmt::Result {
-    color.fmt_prefix(f)?;
-    repeat_char(f, c, n)?;
-    color.fmt_suffix(f)?;
+fn print_indent<F>(f: &mut F, indent: ColoredIndent) -> fmt::Result
+where
+    F: Write,
+{
+    match indent.color {
+        Some(color) => {
+            color.fmt_prefix(f)?;
+            repeat_char(f, indent.space.fill, indent.space.size)?;
+            color.fmt_suffix(f)?;
+        }
+        None => {
+            repeat_char(f, indent.space.fill, indent.space.size)?;
+        }
+    }
 
     Ok(())
 }
 
-fn print_indent2<F: Write>(f: &mut F, indent: Indent, color: StaticColor) -> fmt::Result {
-    print_indent(f, indent.fill, indent.size, color)
+#[derive(Debug, Clone, Copy)]
+struct ColoredIndent {
+    space: Indent,
+    color: Option<StaticColor>,
+}
+
+impl ColoredIndent {
+    fn new(width: usize, c: char, color: Option<StaticColor>) -> Self {
+        Self {
+            space: Indent::new(width, c),
+            color,
+        }
+    }
+
+    fn from_indent(indent: Indent, color: StaticColor) -> Self {
+        Self {
+            space: indent,
+            color: create_color(color),
+        }
+    }
+}
+
+fn create_color(color: StaticColor) -> Option<StaticColor> {
+    if color.is_empty() {
+        None
+    } else {
+        Some(color)
+    }
 }
diff --git a/papergrid/src/grid/iterable.rs b/papergrid/src/grid/iterable.rs
index 67b7108..d24cd47 100644
--- a/papergrid/src/grid/iterable.rs
+++ b/papergrid/src/grid/iterable.rs
@@ -10,14 +10,13 @@ use std::{
 use crate::{
     color::{AnsiColor, Color},
     colors::Colors,
-    config::{AlignmentHorizontal, AlignmentVertical, Indent, Position, Sides},
+    config::spanned::{Offset, SpannedConfig},
+    config::{AlignmentHorizontal, AlignmentVertical, Formatting, Indent, Position, Sides},
     dimension::Dimension,
     records::Records,
     util::string::{count_lines, get_lines, string_width, string_width_multiline, Lines},
 };
 
-use crate::config::spanned::{Formatting, Offset, SpannedConfig};
-
 /// Grid provides a set of methods for building a text-based table.
 #[derive(Debug, Clone)]
 pub struct Grid<R, D, G, C> {
diff --git a/papergrid/src/grid/peekable.rs b/papergrid/src/grid/peekable.rs
index aed568b..b4fb2c9 100644
--- a/papergrid/src/grid/peekable.rs
+++ b/papergrid/src/grid/peekable.rs
@@ -10,7 +10,10 @@ use std::{
 use crate::{
     color::{AnsiColor, Color},
     colors::Colors,
-    config::spanned::{Formatting, Offset, SpannedConfig},
+    config::{
+        spanned::{Offset, SpannedConfig},
+        Formatting,
+    },
     config::{AlignmentHorizontal, AlignmentVertical, Indent, Position, Sides},
     dimension::Dimension,
     records::{ExactRecords, PeekableRecords, Records},
diff --git a/tabled/examples/border_text.rs b/tabled/examples/border_text.rs
index 633f9d3..c2a74a6 100644
--- a/tabled/examples/border_text.rs
+++ b/tabled/examples/border_text.rs
@@ -21,7 +21,7 @@
 use tabled::{
     settings::{
         object::Rows,
-        style::{LineText, Style},
+        style::{HorizontalLine, LineText, StyleBuilder, VerticalLine},
     },
     Table,
 };
@@ -29,15 +29,14 @@ use tabled::{
 fn main() {
     let data = [[5, 6, 7, 8, 9], [10, 11, 12, 13, 14]];
 
+    let line = HorizontalLine::inherit(StyleBuilder::modern())
+        .left(VerticalLine::inherit_left(StyleBuilder::modern()).get_vertical());
+    let style = StyleBuilder::modern()
+        .remove_horizontal()
+        .horizontals([(1, line)]);
+
     let table = Table::new(data)
-        .with(
-            Style::modern().remove_horizontal().horizontals([(
-                1,
-                Style::modern()
-                    .get_horizontal_line()
-                    .left(Style::modern().get_frame().get_left()),
-            )]),
-        )
+        .with(style)
         .with(LineText::new("Numbers").horizontal(Rows::first()).offset(1))
         .with(LineText::new("More numbers").horizontal(1).offset(1))
         .with(LineText::new("end.").horizontal(Rows::last()).offset(1))
diff --git a/tabled/examples/colored_borders.rs b/tabled/examples/colored_borders.rs
index 0bbdb4a..eeeac68 100644
--- a/tabled/examples/colored_borders.rs
+++ b/tabled/examples/colored_borders.rs
@@ -8,10 +8,7 @@
 //! supports custom colors with [`Color::new()`].
 
 use tabled::{
-    settings::{
-        style::{RawStyle, Style},
-        Color,
-    },
+    settings::{style::Style, Color},
     Table, Tabled,
 };
 
@@ -33,23 +30,22 @@ impl CodeEditor {
 }
 
 fn main() {
-    let mut style = RawStyle::from(Style::extended());
-    style
-        .set_color_top(Color::FG_RED)
-        .set_color_bottom(Color::FG_CYAN)
-        .set_color_left(Color::FG_BLUE)
-        .set_color_right(Color::FG_GREEN)
-        .set_color_corner_top_left(Color::FG_BLUE)
-        .set_color_corner_top_right(Color::FG_RED)
-        .set_color_corner_bottom_left(Color::FG_CYAN)
-        .set_color_corner_bottom_right(Color::FG_GREEN)
-        .set_color_intersection_bottom(Color::FG_CYAN)
-        .set_color_intersection_top(Color::FG_RED)
-        .set_color_intersection_right(Color::FG_GREEN)
-        .set_color_intersection_left(Color::FG_BLUE)
-        .set_color_intersection(Color::FG_MAGENTA)
-        .set_color_horizontal(Color::FG_MAGENTA)
-        .set_color_vertical(Color::FG_MAGENTA);
+    let mut style = Style::extended();
+    style.set_color_top(Color::FG_RED);
+    style.set_color_bottom(Color::FG_CYAN);
+    style.set_color_left(Color::FG_BLUE);
+    style.set_color_right(Color::FG_GREEN);
+    style.set_color_corner_top_left(Color::FG_BLUE);
+    style.set_color_corner_top_right(Color::FG_RED);
+    style.set_color_corner_bottom_left(Color::FG_CYAN);
+    style.set_color_corner_bottom_right(Color::FG_GREEN);
+    style.set_color_intersection_bottom(Color::FG_CYAN);
+    style.set_color_intersection_top(Color::FG_RED);
+    style.set_color_intersection_right(Color::FG_GREEN);
+    style.set_color_intersection_left(Color::FG_BLUE);
+    style.set_color_intersection(Color::FG_MAGENTA);
+    style.set_color_horizontal(Color::FG_MAGENTA);
+    style.set_color_vertical(Color::FG_MAGENTA);
 
     let data = [
         CodeEditor::new("Sublime Text 3", "2008", "Sublime HQ"),
diff --git a/tabled/examples/column_names.rs b/tabled/examples/column_names.rs
index 3c06f56..1586aed 100644
--- a/tabled/examples/column_names.rs
+++ b/tabled/examples/column_names.rs
@@ -4,7 +4,7 @@
 
 use tabled::{
     grid::config::AlignmentHorizontal,
-    settings::{themes::ColumnNames, Color, Style},
+    settings::{style::StyleBuilder, themes::ColumnNames, Color},
     Table, Tabled,
 };
 
@@ -51,7 +51,7 @@ fn main() {
 
     let mut table = Table::new(data);
 
-    table.with(Style::modern().remove_horizontal()).with(
+    table.with(StyleBuilder::modern().remove_horizontal()).with(
         ColumnNames::default()
             .set_color(Color::BOLD | Color::BG_BLUE | Color::FG_WHITE)
             .set_alignment(AlignmentHorizontal::Center),
diff --git a/tabled/examples/compact_table.rs b/tabled/examples/compact_table.rs
index 3a02d44..3cb145e 100644
--- a/tabled/examples/compact_table.rs
+++ b/tabled/examples/compact_table.rs
@@ -4,7 +4,7 @@
 //! * [`CompactTable`] is a [`Table`] alternative that trades off reduced
 //! flexibility for improved performance.
 
-use tabled::{settings::Style, tables::CompactTable};
+use tabled::{settings::style::StyleBuilder, tables::CompactTable};
 
 fn main() {
     let data = [
@@ -16,7 +16,7 @@ fn main() {
     let _table = CompactTable::new(data)
         .columns(3)
         .width([7, 5, 5])
-        .with(Style::markdown());
+        .with(StyleBuilder::markdown());
 
     #[cfg(feature = "std")]
     println!("{}", _table.to_string());
diff --git a/tabled/examples/compact_table_2.rs b/tabled/examples/compact_table_2.rs
index 5f231cc..74491d8 100644
--- a/tabled/examples/compact_table_2.rs
+++ b/tabled/examples/compact_table_2.rs
@@ -4,7 +4,7 @@
 //! * Note how [`CompactTable::from()`] inherits the lengths of the nested arrays
 //! as typed definitions through [const generics](https://practice.rs/generics-traits/const-generics.html).
 
-use tabled::{settings::Style, tables::CompactTable};
+use tabled::{settings::style::StyleBuilder, tables::CompactTable};
 
 fn main() {
     let data = [
@@ -13,7 +13,7 @@ fn main() {
         ["Manjaro", "Arch", "true"],
     ];
 
-    let _table = CompactTable::from(data).with(Style::psql());
+    let _table = CompactTable::from(data).with(StyleBuilder::psql());
 
     #[cfg(feature = "std")]
     println!("{}", _table.to_string());
diff --git a/tabled/examples/compact_table_3.rs b/tabled/examples/compact_table_3.rs
index 5c7df6d..57b99e2 100644
--- a/tabled/examples/compact_table_3.rs
+++ b/tabled/examples/compact_table_3.rs
@@ -3,7 +3,7 @@
 //!
 //! * Note how the multiline data is accepted, but then truncated in the display.
 
-use tabled::{settings::Style, tables::CompactTable};
+use tabled::{settings::style::StyleBuilder, tables::CompactTable};
 
 fn main() {
     let data = [
@@ -12,7 +12,7 @@ fn main() {
         ["Manjaro", "A\nr\nc\nh", "true"],
     ];
 
-    let _table = CompactTable::from(data).with(Style::psql());
+    let _table = CompactTable::from(data).with(StyleBuilder::psql());
 
     #[cfg(feature = "std")]
     println!("{}", _table.to_string());
diff --git a/tabled/examples/custom_style.rs b/tabled/examples/custom_style.rs
index 5f28a91..48d3a87 100644
--- a/tabled/examples/custom_style.rs
+++ b/tabled/examples/custom_style.rs
@@ -8,7 +8,10 @@
 //! number of functional columns and rows.
 
 use tabled::{
-    settings::{style::Style, Alignment},
+    settings::{
+        style::{HorizontalLine, StyleBuilder, VerticalLine},
+        Alignment,
+    },
     Table, Tabled,
 };
 
@@ -38,9 +41,9 @@ fn main() {
         CodeEditor::new("Neovim", "2015", "Vim community"),
     ];
 
-    let theme = Style::modern()
-        .horizontals([(1, Style::modern().get_horizontal_line())])
-        .verticals([(1, Style::modern().get_vertical_line())])
+    let theme = StyleBuilder::modern()
+        .horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()))])
+        .verticals([(1, VerticalLine::inherit(StyleBuilder::modern()))])
         .remove_horizontal()
         .remove_vertical();
 
diff --git a/tabled/examples/merge_duplicates_2.rs b/tabled/examples/merge_duplicates_2.rs
index 574a2e8..5650d99 100644
--- a/tabled/examples/merge_duplicates_2.rs
+++ b/tabled/examples/merge_duplicates_2.rs
@@ -7,7 +7,10 @@
 //! * Merge supports both [`Merge::vertical()`] and [`Merge::horizontal()`].
 
 use tabled::{
-    settings::{style::Style, Merge},
+    settings::{
+        style::{HorizontalLine, StyleBuilder, VerticalLine},
+        Border, Merge,
+    },
     Table, Tabled,
 };
 
@@ -57,10 +60,10 @@ impl DatabaseTable {
 }
 
 fn config_theme(table: &mut Table) {
-    let style = Style::modern()
-        .frame(Style::rounded().get_frame())
-        .horizontals([(1, Style::modern().get_horizontal_line())])
-        .verticals([(1, Style::modern().get_vertical_line())])
+    let style = StyleBuilder::modern()
+        .frame(Border::inherit(StyleBuilder::rounded()))
+        .horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()))])
+        .verticals([(1, VerticalLine::inherit(StyleBuilder::modern()))])
         .remove_horizontal()
         .remove_vertical();
 
diff --git a/tabled/examples/nested_table.rs b/tabled/examples/nested_table.rs
index 7084456..9baf382 100644
--- a/tabled/examples/nested_table.rs
+++ b/tabled/examples/nested_table.rs
@@ -13,7 +13,7 @@ use tabled::{
     builder::Builder,
     settings::{
         object::{Rows, Segment},
-        style::Style,
+        style::{HorizontalLine, Style, StyleBuilder},
         Alignment, Modify, Padding, Width,
     },
     Table,
@@ -32,19 +32,23 @@ fn main() {
         &["swim", "quack"],
     );
 
-    let mut table = Builder::from_iter([
+    let data = [
         [animal.to_string()],
         [String::from("▲")],
         [String::from("|")],
         [String::from("|")],
         [duck.to_string()],
-    ])
-    .build();
-    table.with(Style::ascii().remove_horizontal()).with(
-        Modify::new(Segment::all())
-            .with(Padding::new(5, 5, 0, 0))
-            .with(Alignment::center()),
-    );
+    ];
+
+    let mut table = Builder::from_iter(data).build();
+
+    let mut style = Style::ascii();
+    style.set_lines_horizontal(Default::default());
+
+    table
+        .with(style)
+        .with(Padding::new(5, 5, 0, 0))
+        .with(Alignment::center());
 
     println!("{table}");
 }
@@ -54,28 +58,29 @@ fn create_class(name: &str, fields: &[(&str, &str, &str)], methods: &[&str]) ->
         .iter()
         .map(|(field, t, d)| [format_field(field, t, d)]);
     let mut table_fields = Builder::from_iter(fields).build();
-    table_fields.with(Style::ascii().remove_horizontal().remove_vertical());
+    table_fields.with(StyleBuilder::ascii().remove_horizontal().remove_vertical());
 
     let methods = methods.iter().map(|method| [format_method(method)]);
     let mut table_methods = Builder::from_iter(methods).build();
-    table_methods.with(Style::ascii().remove_horizontal().remove_vertical());
+    table_methods.with(StyleBuilder::ascii().remove_horizontal().remove_vertical());
 
     let (table_fields, table_methods) = make_equal_width(table_fields, table_methods);
 
-    let mut table = Builder::from_iter([
+    let data = [
         [name.to_string()],
         [table_fields.to_string()],
         [table_methods.to_string()],
-    ])
-    .build();
+    ];
+
+    let mut table = Builder::from_iter(data).build();
+
+    let style = StyleBuilder::ascii()
+        .horizontals([(1, HorizontalLine::inherit(StyleBuilder::ascii()))])
+        .remove_horizontal()
+        .remove_vertical();
 
     table
-        .with(
-            Style::ascii()
-                .horizontals([(1, Style::ascii().get_horizontal_line())])
-                .remove_horizontal()
-                .remove_vertical(),
-        )
+        .with(style)
         .with(Modify::new(Segment::all()).with(Alignment::left()))
         .with(Modify::new(Rows::first()).with(Alignment::center()));
 
diff --git a/tabled/examples/nested_table_3.rs b/tabled/examples/nested_table_3.rs
index 19b037d..897a011 100644
--- a/tabled/examples/nested_table_3.rs
+++ b/tabled/examples/nested_table_3.rs
@@ -6,7 +6,8 @@
 use tabled::{
     settings::{
         object::{Cell, Segment},
-        Alignment, Border, Extract, Highlight, Modify, Panel, Style,
+        style::StyleBuilder,
+        Alignment, Border, Extract, Highlight, Modify, Panel,
     },
     Table, Tabled,
 };
@@ -48,8 +49,8 @@ fn main() {
         Table::new([String::from("Thank You"), committers_table, issues_table]);
     a_welcome_table
         .with(Extract::rows(1..))
-        .with(Style::ascii().remove_horizontal())
-        .with(Modify::new(Segment::all()).with(Alignment::center()))
+        .with(StyleBuilder::ascii().remove_horizontal())
+        .with(Alignment::center())
         .with(Highlight::border(Cell::new(0, 0), Border::filled('*')));
 
     println!("{a_welcome_table}");
diff --git a/tabled/examples/pool_table.rs b/tabled/examples/pool_table.rs
index 593631e..ad2d51e 100644
--- a/tabled/examples/pool_table.rs
+++ b/tabled/examples/pool_table.rs
@@ -1,7 +1,7 @@
 //! This example demonstrates a [`PoolTable`] usage.
 
 use tabled::{
-    settings::{Alignment, Style},
+    settings::{style::StyleBuilder, Alignment},
     tables::{PoolTable, TableValue},
 };
 
@@ -25,7 +25,7 @@ fn main() {
     );
 
     let table = PoolTable::from(data)
-        .with(Style::modern())
+        .with(StyleBuilder::modern())
         .with(Alignment::center())
         .to_string();
 
diff --git a/tabled/examples/settings_list.rs b/tabled/examples/settings_list.rs
index b0b0aca..a7427f3 100644
--- a/tabled/examples/settings_list.rs
+++ b/tabled/examples/settings_list.rs
@@ -7,8 +7,8 @@
 use tabled::{
     settings::{
         object::{FirstRow, Rows},
-        style::On,
-        Alignment, Modify, ModifyList, Padding, Settings, Style,
+        style::{On, StyleBuilder},
+        Alignment, Modify, ModifyList, Padding, Settings,
     },
     Table, Tabled,
 };
@@ -32,12 +32,12 @@ impl CodeEditor {
 
 // unfortunately we can't leave it as a blank type, so we need to provide it.
 type TableTheme = Settings<
-    Settings<Settings<Settings, Style<On, On, On, On, On, On>>, Padding>,
+    Settings<Settings<Settings, StyleBuilder<On, On, On, On, On, On, 0, 0>>, Padding>,
     ModifyList<FirstRow, Alignment>,
 >;
 
 const THEME: TableTheme = Settings::empty()
-    .with(Style::ascii())
+    .with(StyleBuilder::ascii())
     .with(Padding::new(1, 3, 0, 0))
     .with(Modify::list(Rows::first(), Alignment::center()));
 
diff --git a/tabled/examples/shadow.rs b/tabled/examples/shadow.rs
index b593996..6ce5f6b 100644
--- a/tabled/examples/shadow.rs
+++ b/tabled/examples/shadow.rs
@@ -22,7 +22,7 @@ use tabled::{
     row,
     settings::{
         object::Cell,
-        style::{LineChar, RawStyle, Style},
+        style::{LineChar, Style, StyleBuilder},
         Height, Modify, Padding, Shadow, Width,
     },
     Table,
@@ -62,38 +62,40 @@ fn read_message() -> String {
 }
 
 fn create_small_table_list(width_available: usize) -> String {
+    let style1 = Style::modern();
+    let style2 = Style::extended();
+    let style3 = StyleBuilder::modern()
+        .left('║')
+        .right('║')
+        .intersection_left('╟')
+        .intersection_right('╢')
+        .corner_top_right('╖')
+        .corner_top_left('╓')
+        .corner_bottom_right('╜')
+        .corner_bottom_left('╙')
+        .into();
+    let style4 = StyleBuilder::modern()
+        .top('═')
+        .bottom('═')
+        .corner_top_right('╕')
+        .corner_top_left('╒')
+        .corner_bottom_right('╛')
+        .corner_bottom_left('╘')
+        .horizontal('═')
+        .intersection_left('╞')
+        .intersection_right('╡')
+        .intersection_top('╤')
+        .intersection_bottom('╧')
+        .intersection('╪')
+        .into();
+
     let mut tables = [
-        create_small_table(Style::modern().into()),
-        create_small_table(Style::extended().into()),
-        create_small_table(
-            Style::modern()
-                .left('║')
-                .right('║')
-                .intersection_left('╟')
-                .intersection_right('╢')
-                .corner_top_right('╖')
-                .corner_top_left('╓')
-                .corner_bottom_right('╜')
-                .corner_bottom_left('╙')
-                .into(),
-        ),
-        create_small_table(
-            Style::modern()
-                .top('═')
-                .bottom('═')
-                .corner_top_right('╕')
-                .corner_top_left('╒')
-                .corner_bottom_right('╛')
-                .corner_bottom_left('╘')
-                .horizontal('═')
-                .intersection_left('╞')
-                .intersection_right('╡')
-                .intersection_top('╤')
-                .intersection_bottom('╧')
-                .intersection('╪')
-                .into(),
-        ),
+        create_small_table(style1),
+        create_small_table(style2),
+        create_small_table(style3),
+        create_small_table(style4),
     ];
+
     const TOTAL_TABLE_WIDTH: usize = 19;
 
     if width_available > TOTAL_TABLE_WIDTH {
@@ -118,7 +120,7 @@ fn create_small_table_list(width_available: usize) -> String {
     small_table_row
 }
 
-fn create_small_table(style: RawStyle) -> Table {
+fn create_small_table(style: Style) -> Table {
     let mut table = Builder::from_iter(vec![vec![" ", ""], vec![" ", ""]]).build();
     table
         .with(style)
@@ -157,7 +159,7 @@ fn create_main_table(message: &str) -> Table {
     let mut table = row![left_table, message];
     table
         .with(Padding::zero())
-        .with(Style::modern().remove_vertical())
+        .with(StyleBuilder::modern().remove_vertical())
         .with(Modify::new(Cell::new(0, 0)).with(LineChar::vertical('╞', count_lines)))
         .with(Modify::new(Cell::new(0, 2)).with(LineChar::vertical('╡', count_lines)))
         .with(Shadow::new(2));
diff --git a/tabled/examples/style_modern_rounded.rs b/tabled/examples/style_modern_rounded.rs
index d3e7b7b..7199cc4 100644
--- a/tabled/examples/style_modern_rounded.rs
+++ b/tabled/examples/style_modern_rounded.rs
@@ -1,35 +1,32 @@
 use tabled::{
     settings::{
-        style::{On, RawStyle},
-        Style,
+        style::{HorizontalLine, On, Style, StyleBuilder},
+        Border,
     },
     Table,
 };
 
-type FullStyle = Style<On, On, On, On, On, On>;
+const STYLE_1: StyleBuilder<On, On, On, On, On, On, 0, 0> =
+    StyleBuilder::modern().frame(Border::inherit(StyleBuilder::rounded()));
 
-const STYLE_1: FullStyle = Style::modern().frame(Style::rounded().get_frame());
-
-const STYLE_2: FullStyle = Style::rounded()
-    .horizontal_line(Style::modern().get_horizontal_line())
+const STYLE_2: StyleBuilder<On, On, On, On, On, On, 0, 0> = StyleBuilder::rounded()
+    .line_horizontal(HorizontalLine::inherit(StyleBuilder::modern()))
     .remove_horizontals();
 
 fn main() {
-    assert_eq!(RawStyle::from(STYLE_1), RawStyle::from(STYLE_2));
-
-    let data = vec![("Hello", "world", "!"); 5];
-
-    let mut table = Table::new(&data);
-    table.with(STYLE_2);
+    assert_eq!(Style::from(STYLE_1), Style::from(STYLE_2));
 
-    let output = table.to_string();
+    let data = vec![("Hello", "world", "!"); 3];
 
-    println!("{output}");
+    let mut table1 = Table::new(&data);
+    table1.with(STYLE_2);
 
-    let mut table = Table::new(&data);
-    table.with(STYLE_1);
+    let mut table2 = Table::new(&data);
+    table2.with(STYLE_1);
 
-    let output = table.to_string();
+    let output1 = table1.to_string();
+    let output2 = table2.to_string();
+    let output = Table::new([(output1, output2)]);
 
-    println!("{output}");
+    println!("{}", output);
 }
diff --git a/tabled/src/grid/compact_multiline_config.rs b/tabled/src/grid/compact_multiline_config.rs
index c9056c9..1c069b6 100644
--- a/tabled/src/grid/compact_multiline_config.rs
+++ b/tabled/src/grid/compact_multiline_config.rs
@@ -1,9 +1,11 @@
-use crate::grid::color::StaticColor;
-use crate::grid::config::{
-    AlignmentHorizontal, AlignmentVertical, Borders, CompactConfig, Indent, Line, Sides,
+use crate::grid::{
+    color::StaticColor,
+    config::{
+        AlignmentHorizontal, AlignmentVertical, Borders, CompactConfig, Formatting, Indent, Sides,
+    },
 };
 
-/// A [`CompactConfig`] configuration plus vertical alignment.
+/// A [`CompactConfig`] based configuration plus vertical alignment and formatting options.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct CompactMultilineConfig {
     config: CompactConfig,
@@ -12,15 +14,27 @@ pub struct CompactMultilineConfig {
 }
 
 impl CompactMultilineConfig {
-    /// Create a new colored config.
-    pub fn new(config: CompactConfig) -> Self {
-        Self::from(config)
+    /// Create a new [`CompactMultilineConfig`].
+    pub const fn new() -> Self {
+        Self {
+            config: CompactConfig::new(),
+            alignment_vertical: AlignmentVertical::Top,
+            formatting: Formatting::new(false, false, false),
+        }
+    }
+
+    /// Create a new [`CompactMultilineConfig`].
+    pub const fn from_compact(config: CompactConfig) -> Self {
+        Self {
+            config,
+            alignment_vertical: AlignmentVertical::Top,
+            formatting: Formatting::new(false, false, false),
+        }
     }
 
     /// Set a horizontal alignment.
-    pub const fn set_alignment_vertical(mut self, alignment: AlignmentVertical) -> Self {
-        self.alignment_vertical = alignment;
-        self
+    pub fn set_alignment_vertical(&mut self, alignment: AlignmentVertical) {
+        self.alignment_vertical = alignment
     }
 
     /// Get a alignment horizontal.
@@ -29,9 +43,8 @@ impl CompactMultilineConfig {
     }
 
     /// Set grid margin.
-    pub const fn set_margin(mut self, margin: Sides<Indent>) -> Self {
+    pub fn set_margin(&mut self, margin: Sides<Indent>) {
         self.config = self.config.set_margin(margin);
-        self
     }
 
     /// Returns a grid margin.
@@ -40,24 +53,8 @@ impl CompactMultilineConfig {
     }
 
     /// Set the [`Borders`] value as correct one.
-    pub const fn set_borders(mut self, borders: Borders<char>) -> Self {
-        self.config = self.config.set_borders(borders);
-        self
-    }
-
-    /// Set the first horizontal line.
-    ///
-    /// It ignores the [`Borders`] horizontal value if set for 1st row.
-    pub const fn set_first_horizontal_line(mut self, line: Line<char>) -> Self {
-        self.config = self.config.set_first_horizontal_line(line);
-        self
-    }
-
-    /// Set the first horizontal line.
-    ///
-    /// It ignores the [`Borders`] horizontal value if set for 1st row.
-    pub const fn get_first_horizontal_line(&self) -> Option<Line<char>> {
-        self.config.get_first_horizontal_line()
+    pub fn set_borders(&mut self, borders: Borders<char>) {
+        self.config = self.config.set_borders(borders)
     }
 
     /// Returns a current [`Borders`] structure.
@@ -71,9 +68,8 @@ impl CompactMultilineConfig {
     }
 
     /// Set a padding to a given cells.
-    pub const fn set_padding(mut self, padding: Sides<Indent>) -> Self {
-        self.config = self.config.set_padding(padding);
-        self
+    pub fn set_padding(&mut self, padding: Sides<Indent>) {
+        self.config = self.config.set_padding(padding)
     }
 
     /// Get a padding for a given.
@@ -82,9 +78,8 @@ impl CompactMultilineConfig {
     }
 
     /// Set a horizontal alignment.
-    pub const fn set_alignment_horizontal(mut self, alignment: AlignmentHorizontal) -> Self {
-        self.config = self.config.set_alignment_horizontal(alignment);
-        self
+    pub fn set_alignment_horizontal(&mut self, alignment: AlignmentHorizontal) {
+        self.config = self.config.set_alignment_horizontal(alignment)
     }
 
     /// Get a alignment horizontal.
@@ -93,37 +88,33 @@ impl CompactMultilineConfig {
     }
 
     /// Sets colors of border carcass on the grid.
-    pub const fn set_borders_color(mut self, borders: Borders<StaticColor>) -> Self {
-        self.config = self.config.set_borders_color(borders);
-        self
+    pub fn set_borders_color(&mut self, borders: Borders<StaticColor>) {
+        self.config = self.config.set_borders_color(borders)
     }
 
     /// Set colors for a margin.
-    pub const fn set_margin_color(mut self, color: Sides<StaticColor>) -> Self {
-        self.config = self.config.set_margin_color(color);
-        self
+    pub fn set_margin_color(&mut self, color: Sides<StaticColor>) {
+        self.config = self.config.set_margin_color(color)
     }
 
     /// Returns a margin color.
-    pub const fn get_margin_color(&self) -> Sides<StaticColor> {
+    pub const fn get_margin_color(&self) -> &Sides<StaticColor> {
         self.config.get_margin_color()
     }
 
     /// Set a padding color to all cells.
-    pub const fn set_padding_color(mut self, color: Sides<StaticColor>) -> Self {
-        self.config = self.config.set_padding_color(color);
-        self
+    pub fn set_padding_color(&mut self, color: Sides<StaticColor>) {
+        self.config = self.config.set_padding_color(color)
     }
 
     /// get a padding color.
-    pub const fn get_padding_color(&self) -> Sides<StaticColor> {
+    pub const fn get_padding_color(&self) -> &Sides<StaticColor> {
         self.config.get_padding_color()
     }
 
     /// Set formatting.
-    pub const fn set_formatting(mut self, formatting: Formatting) -> Self {
-        self.formatting = formatting;
-        self
+    pub fn set_formatting(&mut self, formatting: Formatting) {
+        self.formatting = formatting
     }
 
     /// Get formatting.
@@ -142,6 +133,12 @@ impl Default for CompactMultilineConfig {
     }
 }
 
+impl From<CompactMultilineConfig> for CompactConfig {
+    fn from(cfg: CompactMultilineConfig) -> Self {
+        cfg.config
+    }
+}
+
 impl From<CompactConfig> for CompactMultilineConfig {
     fn from(config: CompactConfig) -> Self {
         Self {
@@ -152,60 +149,16 @@ impl From<CompactConfig> for CompactMultilineConfig {
     }
 }
 
-impl AsRef<CompactConfig> for CompactMultilineConfig {
-    fn as_ref(&self) -> &CompactConfig {
-        &self.config
-    }
-}
-
-impl AsMut<CompactConfig> for CompactMultilineConfig {
-    fn as_mut(&mut self) -> &mut CompactConfig {
-        &mut self.config
-    }
-}
-
 #[cfg(feature = "std")]
 impl From<CompactMultilineConfig> for crate::grid::config::SpannedConfig {
     fn from(compact: CompactMultilineConfig) -> Self {
-        use crate::grid::config::Entity;
+        use crate::grid::config::Entity::*;
+        use crate::grid::config::SpannedConfig;
 
-        let mut cfg = crate::grid::config::SpannedConfig::from(compact.config);
-        cfg.set_alignment_vertical(Entity::Global, compact.alignment_vertical);
-        cfg.set_formatting(Entity::Global, compact.formatting.into());
+        let mut cfg = SpannedConfig::from(compact.config);
+        cfg.set_alignment_vertical(Global, compact.alignment_vertical);
+        cfg.set_formatting(Global, compact.formatting);
 
         cfg
     }
 }
-
-/// Formatting represent a logic of formatting of a cell.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Formatting {
-    /// An setting to allow horizontal trim.
-    pub horizontal_trim: bool,
-    /// An setting to allow vertical trim.
-    pub vertical_trim: bool,
-    /// An setting to allow alignment per line.
-    pub allow_lines_alignment: bool,
-}
-
-impl Formatting {
-    /// Creates a new [`Formatting`] structure.
-    pub fn new(horizontal_trim: bool, vertical_trim: bool, allow_lines_alignment: bool) -> Self {
-        Self {
-            horizontal_trim,
-            vertical_trim,
-            allow_lines_alignment,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<Formatting> for crate::grid::config::Formatting {
-    fn from(val: Formatting) -> Self {
-        crate::grid::config::Formatting {
-            allow_lines_alignment: val.allow_lines_alignment,
-            horizontal_trim: val.horizontal_trim,
-            vertical_trim: val.vertical_trim,
-        }
-    }
-}
diff --git a/tabled/src/grid/mod.rs b/tabled/src/grid/mod.rs
index cdd8c55..db03013 100644
--- a/tabled/src/grid/mod.rs
+++ b/tabled/src/grid/mod.rs
@@ -21,14 +21,12 @@ pub mod config {
 
     pub use papergrid::config::{
         compact::CompactConfig, AlignmentHorizontal, AlignmentVertical, Border, Borders, Entity,
-        EntityIterator, Indent, Line, Position, Sides,
+        EntityIterator, Formatting, HorizontalLine, Indent, Position, Sides, VerticalLine,
     };
 
     #[cfg(feature = "std")]
     #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    pub use papergrid::config::spanned::{
-        EntityMap, Formatting, HorizontalLine, Offset, SpannedConfig, VerticalLine,
-    };
+    pub use papergrid::config::spanned::{EntityMap, Offset, SpannedConfig};
 
     #[cfg(feature = "std")]
     #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
diff --git a/tabled/src/settings/alignment/mod.rs b/tabled/src/settings/alignment/mod.rs
index f025329..f6a7644 100644
--- a/tabled/src/settings/alignment/mod.rs
+++ b/tabled/src/settings/alignment/mod.rs
@@ -191,8 +191,8 @@ impl<R, D> TableOption<R, D, CompactConfig> for Alignment {
 impl<R, D> TableOption<R, D, CompactMultilineConfig> for Alignment {
     fn change(self, _: &mut R, cfg: &mut CompactMultilineConfig, _: &mut D) {
         match self.inner {
-            Horizontal(a) => *cfg = cfg.set_alignment_horizontal(a),
-            Vertical(a) => *cfg = cfg.set_alignment_vertical(a),
+            Horizontal(a) => cfg.set_alignment_horizontal(a),
+            Vertical(a) => cfg.set_alignment_vertical(a),
         }
     }
 
diff --git a/tabled/src/settings/formatting/alignment_strategy.rs b/tabled/src/settings/formatting/alignment_strategy.rs
index a0aa5a3..547ebec 100644
--- a/tabled/src/settings/formatting/alignment_strategy.rs
+++ b/tabled/src/settings/formatting/alignment_strategy.rs
@@ -171,7 +171,7 @@ impl<R, D> TableOption<R, D, CompactMultilineConfig> for AlignmentStrategy {
             AlignmentStrategy::PerLine => f.allow_lines_alignment = true,
         }
 
-        *cfg = cfg.set_formatting(f);
+        cfg.set_formatting(f);
     }
 
     fn hint_change(&self) -> Option<Entity> {
diff --git a/tabled/src/settings/margin/mod.rs b/tabled/src/settings/margin/mod.rs
index b86a1d3..0f9917c 100644
--- a/tabled/src/settings/margin/mod.rs
+++ b/tabled/src/settings/margin/mod.rs
@@ -131,7 +131,13 @@ impl<R, D, C> TableOption<R, D, CompactMultilineConfig> for Margin<C>
 where
     C: Into<StaticColor> + Clone,
 {
-    fn change(self, records: &mut R, cfg: &mut CompactMultilineConfig, dimension: &mut D) {
-        self.change(records, cfg.as_mut(), dimension)
+    fn change(self, _: &mut R, cfg: &mut CompactMultilineConfig, _: &mut D) {
+        cfg.set_margin(self.indent);
+
+        if let Some(c) = self.colors {
+            // todo: make a new method (BECAUSE INTO doesn't work) try_into();
+            let colors = Sides::new(c.left.into(), c.right.into(), c.top.into(), c.bottom.into());
+            cfg.set_margin_color(colors);
+        }
     }
 }
diff --git a/tabled/src/settings/mod.rs b/tabled/src/settings/mod.rs
index 238edbd..b025692 100644
--- a/tabled/src/settings/mod.rs
+++ b/tabled/src/settings/mod.rs
@@ -123,13 +123,13 @@ pub use modify::{Modify, ModifyList};
 
 pub use self::{
     alignment::Alignment, extract::Extract, margin::Margin, padding::Padding, rotate::Rotate,
-    style::Style,
+    style::Border,
 };
 
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 pub use self::{
     color::Color, concat::Concat, disable::Disable, duplicate::Dup, format::Format, height::Height,
-    highlight::Highlight, merge::Merge, panel::Panel, shadow::Shadow, span::Span, style::Border,
+    highlight::Highlight, merge::Merge, panel::Panel, shadow::Shadow, span::Span, style::Style,
     width::Width,
 };
diff --git a/tabled/src/settings/padding/mod.rs b/tabled/src/settings/padding/mod.rs
index af343b3..f9b9d28 100644
--- a/tabled/src/settings/padding/mod.rs
+++ b/tabled/src/settings/padding/mod.rs
@@ -158,7 +158,12 @@ impl<R, D, C> TableOption<R, D, CompactMultilineConfig> for Padding<C>
 where
     C: Into<StaticColor> + Clone,
 {
-    fn change(self, records: &mut R, cfg: &mut CompactMultilineConfig, dimension: &mut D) {
-        self.change(records, cfg.as_mut(), dimension)
+    fn change(self, _: &mut R, cfg: &mut CompactMultilineConfig, _: &mut D) {
+        cfg.set_padding(self.indent);
+
+        if let Some(c) = self.colors {
+            let colors = Sides::new(c.left.into(), c.right.into(), c.top.into(), c.bottom.into());
+            cfg.set_padding_color(colors);
+        }
     }
 }
diff --git a/tabled/src/settings/style/border.rs b/tabled/src/settings/style/border.rs
index d333f41..18dad9e 100644
--- a/tabled/src/settings/style/border.rs
+++ b/tabled/src/settings/style/border.rs
@@ -1,11 +1,15 @@
 use core::marker::PhantomData;
 
 use crate::{
-    grid::{
-        config::{Border as GridBorder, ColoredConfig, Entity},
-        records::{ExactRecords, Records},
-    },
-    settings::{style::On, CellOption},
+    grid::config::Border as GridBorder,
+    settings::{style::On, style::StyleBuilder},
+};
+
+#[cfg(feature = "std")]
+use crate::{
+    grid::config::{ColoredConfig, Entity},
+    grid::records::{ExactRecords, Records},
+    settings::CellOption,
 };
 
 /// Border represents a border of a Cell.
@@ -96,6 +100,27 @@ impl Border<On, On, On, On> {
     }
 }
 
+impl<T, B, L, R> Border<T, B, L, R> {
+    /// Fetches outer border from a style.
+    pub const fn inherit<H, V, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = GridBorder::new(
+            borders.top,
+            borders.bottom,
+            borders.left,
+            borders.right,
+            borders.top_left,
+            borders.bottom_left,
+            borders.top_right,
+            borders.bottom_right,
+        );
+
+        Self::from_border(line)
+    }
+}
+
 impl<T, B, L, R> Border<T, B, L, R> {
     /// Set a top border character.
     pub const fn set_top(mut self, c: char) -> Border<On, B, L, R> {
@@ -213,6 +238,8 @@ impl<T, B, L, R> From<Border<T, B, L, R>> for GridBorder<char> {
     }
 }
 
+#[cfg(feature = "std")]
+
 impl<T, B, L, R, Data> CellOption<Data, ColoredConfig> for Border<T, B, L, R>
 where
     Data: Records + ExactRecords,
@@ -222,10 +249,8 @@ where
     }
 }
 
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct EmptyBorder;
-
-impl<R> CellOption<R, ColoredConfig> for EmptyBorder
+#[cfg(feature = "std")]
+impl<R> CellOption<R, ColoredConfig> for GridBorder<char>
 where
     R: Records + ExactRecords,
 {
@@ -233,19 +258,16 @@ where
         let shape = (records.count_rows(), records.count_columns());
 
         for pos in entity.iter(shape.0, shape.1) {
-            cfg.remove_border(pos, shape);
+            cfg.set_border(pos, self);
         }
     }
 }
 
-const fn get_char(c: Option<char>) -> char {
-    match c {
-        Some(c) => c,
-        None => unreachable!(),
-    }
-}
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct EmptyBorder;
 
-impl<R> CellOption<R, ColoredConfig> for GridBorder<char>
+#[cfg(feature = "std")]
+impl<R> CellOption<R, ColoredConfig> for EmptyBorder
 where
     R: Records + ExactRecords,
 {
@@ -253,7 +275,14 @@ where
         let shape = (records.count_rows(), records.count_columns());
 
         for pos in entity.iter(shape.0, shape.1) {
-            cfg.set_border(pos, self);
+            cfg.remove_border(pos, shape);
         }
     }
 }
+
+const fn get_char(c: Option<char>) -> char {
+    match c {
+        Some(c) => c,
+        None => unreachable!(),
+    }
+}
diff --git a/tabled/src/settings/style/builder.rs b/tabled/src/settings/style/builder.rs
index 6acb8bc..442069e 100644
--- a/tabled/src/settings/style/builder.rs
+++ b/tabled/src/settings/style/builder.rs
@@ -3,17 +3,15 @@
 use core::marker::PhantomData;
 
 use crate::{
-    grid::config::{Borders, CompactConfig, CompactMultilineConfig},
-    settings::TableOption,
+    grid::config::{Border as GridBorder, Borders, CompactConfig, CompactMultilineConfig},
+    settings::{
+        style::{HorizontalLine, VerticalLine},
+        Border, TableOption,
+    },
 };
 
 #[cfg(feature = "std")]
-use crate::{
-    grid::config::{Border as GridBorder, ColoredConfig},
-    settings::Border,
-};
-
-use super::{HorizontalLine, Line, VerticalLine};
+use crate::{grid::config::ColoredConfig, settings::Style};
 
 /// Style is represents a theme of a [`Table`].
 ///
@@ -51,7 +49,7 @@ use super::{HorizontalLine, Line, VerticalLine};
 /// ```
 ///
 /// It tries to limit an controlling a valid state of it.
-/// For example, it won't allow to call method [`Style::corner_top_left`] unless [`Style::left`] and [`Style::top`] is set.
+/// For example, it won't allow to call method [`StyleBuilder::corner_top_left`] unless [`StyleBuilder::left`] and [`StyleBuilder::top`] is set.
 ///
 /// You can turn [`Style`] into [`RawStyle`] to have more control using [`Into`] implementation.
 ///
@@ -59,25 +57,27 @@ use super::{HorizontalLine, Line, VerticalLine};
 ///
 #[cfg_attr(feature = "std", doc = "```")]
 #[cfg_attr(not(feature = "std"), doc = "```ignore")]
-/// use tabled::{Table, settings::Style};
+/// use tabled::{Table, settings::style::StyleBuilder};
 ///
 /// let data = vec!["Hello", "2021"];
-/// let style = Style::ascii().bottom('*').intersection(' ');
-/// let table = Table::new(&data).with(style).to_string();
+/// let mut table = Table::new(&data);
+///
+/// let style = StyleBuilder::ascii().bottom('*').intersection(' ');
+/// table.with(style);
 ///
 /// println!("{}", table);
 /// ```
 ///
 /// [`Table`]: crate::Table
-/// [`RawStyle`]: crate::settings::style::RawStyle
-/// [`Style::corner_top_left`]: Style::corner_top_left
-/// [`Style::left`]: Style.left
-/// [`Style::top`]: Style.function.top
+/// [`RawStyle`]: crate::settings::StyleBuilder::RawStyle
+/// [`StyleBuilder::corner_top_left`]: StyleBuilder::corner_top_left
+/// [`StyleBuilder::left`]: Style.left
+/// [`StyleBuilder::top`]: Style.function.top
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Style<T, B, L, R, H, V, const HSIZE: usize = 0, const VSIZE: usize = 0> {
+pub struct StyleBuilder<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize> {
     borders: Borders<char>,
-    horizontals: HArray<L, R, V, HSIZE>,
-    verticals: VArray<T, B, H, VSIZE>,
+    horizontals: HArray<HSIZE>,
+    verticals: VArray<VSIZE>,
     _top: PhantomData<T>,
     _bottom: PhantomData<B>,
     _left: PhantomData<L>,
@@ -86,14 +86,17 @@ pub struct Style<T, B, L, R, H, V, const HSIZE: usize = 0, const VSIZE: usize =
     _vertical: PhantomData<V>,
 }
 
-type HArray<L, R, I, const N: usize> = [(usize, HorizontalLine<L, R, I>); N];
-type VArray<T, B, I, const N: usize> = [(usize, VerticalLine<T, B, I>); N];
+type HLine = crate::grid::config::HorizontalLine<char>;
+type VLine = crate::grid::config::VerticalLine<char>;
+
+type HArray<const N: usize> = [(usize, HLine); N];
+type VArray<const N: usize> = [(usize, VLine); N];
 
 /// A marker struct which is used in [`Style`].
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default, Hash)]
 pub struct On;
 
-impl Style<(), (), (), (), (), ()> {
+impl StyleBuilder<(), (), (), (), (), (), 0, 0> {
     /// This style is a style with no styling options on,
     ///
     /// ```text
@@ -108,26 +111,15 @@ impl Style<(), (), (), (), (), ()> {
     /// This style can be used as a base style to build a custom one.
     ///
     /// ```rust,no_run
-    /// # use tabled::settings::Style;
-    /// let style = Style::empty()
+    /// # use tabled::settings::style::StyleBuilder;
+    /// let style = StyleBuilder::empty()
     ///     .top('*')
     ///     .bottom('*')
     ///     .vertical('#')
     ///     .intersection_top('*');
     /// ```
-    pub const fn empty() -> Style<(), (), (), (), (), ()> {
-        Style::new(
-            create_borders(
-                Line::empty(),
-                Line::empty(),
-                Line::empty(),
-                None,
-                None,
-                None,
-            ),
-            [],
-            [],
-        )
+    pub const fn empty() -> StyleBuilder<(), (), (), (), (), (), 0, 0> {
+        StyleBuilder::new(Borders::empty(), [], [])
     }
 
     /// This style is analog of `empty` but with a vertical space(' ') line.
@@ -138,12 +130,12 @@ impl Style<(), (), (), (), (), ()> {
     ///      2      OpenSUSE     https://www.opensuse.org/
     ///      3    Endeavouros    https://endeavouros.com/
     /// ```
-    pub const fn blank() -> Style<(), (), (), (), (), On> {
-        Style::new(
+    pub const fn blank() -> StyleBuilder<(), (), (), (), (), On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::empty(),
-                Line::empty(),
-                Line::empty(),
+                HLine::empty(),
+                HLine::empty(),
+                HLine::empty(),
                 None,
                 None,
                 Some(' '),
@@ -168,12 +160,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     | 3  | Endeavouros  | https://endeavouros.com/  |
     ///     +----+--------------+---------------------------+
     /// ```
-    pub const fn ascii() -> Style<On, On, On, On, On, On> {
-        Style::new(
+    pub const fn ascii() -> StyleBuilder<On, On, On, On, On, On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('-', '+', '+', '+'),
-                Line::full('-', '+', '+', '+'),
-                Line::full('-', '+', '+', '+'),
+                HLine::full('-', '+', '+', '+'),
+                HLine::full('-', '+', '+', '+'),
+                HLine::full('-', '+', '+', '+'),
                 Some('|'),
                 Some('|'),
                 Some('|'),
@@ -195,17 +187,17 @@ impl Style<(), (), (), (), (), ()> {
     ///      2  |   OpenSUSE   | https://www.opensuse.org/
     ///      3  | Endeavouros  | https://endeavouros.com/
     /// ```
-    pub const fn psql() -> Style<(), (), (), (), (), On, 1, 0> {
-        Style::new(
+    pub const fn psql() -> StyleBuilder<(), (), (), (), (), On, 1, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::empty(),
-                Line::empty(),
-                Line::empty(),
+                HLine::empty(),
+                HLine::empty(),
+                HLine::empty(),
                 None,
                 None,
                 Some('|'),
             ),
-            [(1, HorizontalLine::new('-').intersection('+'))],
+            [(1, HLine::new(Some('-'), Some('+'), None, None))],
             [],
         )
     }
@@ -219,22 +211,22 @@ impl Style<(), (), (), (), (), ()> {
     ///     | 2  |   OpenSUSE   | https://www.opensuse.org/ |
     ///     | 3  | Endeavouros  | https://endeavouros.com/  |
     /// ```
-    pub const fn markdown() -> Style<(), (), On, On, (), On, 1, 0> {
-        Style::new(
+    pub const fn markdown() -> StyleBuilder<(), (), On, On, (), On, 1, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::empty(),
-                Line::empty(),
-                Line::empty(),
+                HLine::empty(),
+                HLine::empty(),
+                HLine::empty(),
                 Some('|'),
                 Some('|'),
                 Some('|'),
             ),
-            [(1, HorizontalLine::full('-', '|', '|', '|'))],
+            [(1, HLine::full('-', '|', '|', '|'))],
             [],
         )
     }
 
-    /// This style is analog of [`Style::ascii`] which uses UTF-8 charset.
+    /// This style is analog of [`StyleBuilder::ascii`] which uses UTF-8 charset.
     ///
     /// It has vertical and horizontal split lines.
     ///
@@ -249,12 +241,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
     ///     └────┴──────────────┴───────────────────────────┘
     /// ```
-    pub const fn modern() -> Style<On, On, On, On, On, On> {
-        Style::new(
+    pub const fn modern() -> StyleBuilder<On, On, On, On, On, On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('─', '┬', '┌', '┐'),
-                Line::full('─', '┴', '└', '┘'),
-                Line::full('─', '┼', '├', '┤'),
+                HLine::full('─', '┬', '┌', '┐'),
+                HLine::full('─', '┴', '└', '┘'),
+                HLine::full('─', '┼', '├', '┤'),
                 Some('│'),
                 Some('│'),
                 Some('│'),
@@ -264,7 +256,7 @@ impl Style<(), (), (), (), (), ()> {
         )
     }
 
-    /// This style looks like a [`Style::modern`] but without horozizontal lines except a header.
+    /// This style looks like a [`StyleBuilder::modern`] but without horozizontal lines except a header.
     ///
     /// Beware: It uses UTF-8 characters.
     ///
@@ -277,22 +269,22 @@ impl Style<(), (), (), (), (), ()> {
     ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
     ///     └────┴──────────────┴───────────────────────────┘
     /// ```
-    pub const fn sharp() -> Style<On, On, On, On, (), On, 1, 0> {
-        Style::new(
+    pub const fn sharp() -> StyleBuilder<On, On, On, On, (), On, 1, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('─', '┬', '┌', '┐'),
-                Line::full('─', '┴', '└', '┘'),
-                Line::empty(),
+                HLine::full('─', '┬', '┌', '┐'),
+                HLine::full('─', '┴', '└', '┘'),
+                HLine::empty(),
                 Some('│'),
                 Some('│'),
                 Some('│'),
             ),
-            [(1, HorizontalLine::full('─', '├', '┤', '┼'))],
+            [(1, HLine::full('─', '┼', '├', '┤'))],
             [],
         )
     }
 
-    /// This style looks like a [`Style::sharp`] but with rounded corners.
+    /// This style looks like a [`StyleBuilder::sharp`] but with rounded corners.
     ///
     /// Beware: It uses UTF-8 characters.
     ///
@@ -305,22 +297,22 @@ impl Style<(), (), (), (), (), ()> {
     ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
     ///     ╰────┴──────────────┴───────────────────────────╯
     /// ```
-    pub const fn rounded() -> Style<On, On, On, On, (), On, 1, 0> {
-        Style::new(
+    pub const fn rounded() -> StyleBuilder<On, On, On, On, (), On, 1, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('─', '┬', '╭', '╮'),
-                Line::full('─', '┴', '╰', '╯'),
-                Line::empty(),
+                HLine::full('─', '┬', '╭', '╮'),
+                HLine::full('─', '┴', '╰', '╯'),
+                HLine::empty(),
                 Some('│'),
                 Some('│'),
                 Some('│'),
             ),
-            [(1, HorizontalLine::full('─', '├', '┤', '┼'))],
+            [(1, HLine::full('─', '┼', '├', '┤'))],
             [],
         )
     }
 
-    /// This style looks like a [`Style::rounded`] but with horizontals lines.
+    /// This style looks like a [`StyleBuilder::rounded`] but with horizontals lines.
     ///
     /// Beware: It uses UTF-8 characters.
     ///
@@ -335,12 +327,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
     ///     ╰────┴──────────────┴───────────────────────────╯
     /// ```
-    pub const fn modern_rounded() -> Style<On, On, On, On, On, On, 0, 0> {
-        Style::new(
+    pub const fn modern_rounded() -> StyleBuilder<On, On, On, On, On, On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('─', '┬', '╭', '╮'),
-                Line::full('─', '┴', '╰', '╯'),
-                Line::full('─', '┼', '├', '┤'),
+                HLine::full('─', '┬', '╭', '╮'),
+                HLine::full('─', '┴', '╰', '╯'),
+                HLine::full('─', '┼', '├', '┤'),
                 Some('│'),
                 Some('│'),
                 Some('│'),
@@ -365,12 +357,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     ║ 3  ║ Endeavouros  ║ https://endeavouros.com/  ║
     ///     ╚════╩══════════════╩═══════════════════════════╝
     /// ```
-    pub const fn extended() -> Style<On, On, On, On, On, On> {
-        Style::new(
+    pub const fn extended() -> StyleBuilder<On, On, On, On, On, On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('═', '╦', '╔', '╗'),
-                Line::full('═', '╩', '╚', '╝'),
-                Line::full('═', '╬', '╠', '╣'),
+                HLine::full('═', '╦', '╔', '╗'),
+                HLine::full('═', '╩', '╚', '╝'),
+                HLine::full('═', '╬', '╠', '╣'),
                 Some('║'),
                 Some('║'),
                 Some('║'),
@@ -394,12 +386,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     : 3  : Endeavouros  : https://endeavouros.com/  :
     ///     :....:..............:...........................:
     /// ```
-    pub const fn dots() -> Style<On, On, On, On, On, On> {
-        Style::new(
+    pub const fn dots() -> StyleBuilder<On, On, On, On, On, On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('.', '.', '.', '.'),
-                Line::full('.', ':', ':', ':'),
-                Line::full('.', ':', ':', ':'),
+                HLine::full('.', '.', '.', '.'),
+                HLine::full('.', ':', ':', ':'),
+                HLine::full('.', ':', ':', ':'),
                 Some(':'),
                 Some(':'),
                 Some(':'),
@@ -420,22 +412,22 @@ impl Style<(), (), (), (), (), ()> {
     ///      3    Endeavouros    https://endeavouros.com/  
     ///     ==== ============== ===========================
     /// ```
-    pub const fn re_structured_text() -> Style<On, On, (), (), (), On, 1, 0> {
-        Style::new(
+    pub const fn re_structured_text() -> StyleBuilder<On, On, (), (), (), On, 1, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::new(Some('='), Some(' '), None, None),
-                Line::new(Some('='), Some(' '), None, None),
-                Line::empty(),
+                HLine::new(Some('='), Some(' '), None, None),
+                HLine::new(Some('='), Some(' '), None, None),
+                HLine::empty(),
                 None,
                 None,
                 Some(' '),
             ),
-            [(1, HorizontalLine::new('=').intersection(' '))],
+            [(1, HLine::new(Some('='), Some(' '), None, None))],
             [],
         )
     }
 
-    /// This is a theme analog of [`Style::rounded`], but in using ascii charset and
+    /// This is a theme analog of [`StyleBuilder::rounded`], but in using ascii charset and
     /// with no horizontal lines.
     ///
     /// ```text
@@ -446,12 +438,12 @@ impl Style<(), (), (), (), (), ()> {
     ///     | 3  | Endeavouros  | https://endeavouros.com/  |
     ///     '-----------------------------------------------'
     /// ```
-    pub const fn ascii_rounded() -> Style<On, On, On, On, (), On> {
-        Style::new(
+    pub const fn ascii_rounded() -> StyleBuilder<On, On, On, On, (), On, 0, 0> {
+        StyleBuilder::new(
             create_borders(
-                Line::full('-', '-', '.', '.'),
-                Line::full('-', '-', '\'', '\''),
-                Line::empty(),
+                HLine::full('-', '-', '.', '.'),
+                HLine::full('-', '-', '\'', '\''),
+                HLine::empty(),
                 Some('|'),
                 Some('|'),
                 Some('|'),
@@ -463,12 +455,12 @@ impl Style<(), (), (), (), (), ()> {
 }
 
 impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
-    Style<T, B, L, R, H, V, HSIZE, VSIZE>
+    StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>
 {
-    const fn new(
+    pub(crate) const fn new(
         borders: Borders<char>,
-        horizontals: HArray<L, R, V, HSIZE>,
-        verticals: VArray<T, B, H, VSIZE>,
+        horizontals: HArray<HSIZE>,
+        verticals: VArray<VSIZE>,
     ) -> Self {
         Self {
             borders,
@@ -482,29 +474,58 @@ impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
             _vertical: PhantomData,
         }
     }
+
+    pub(crate) const fn get_borders(&self) -> Borders<char> {
+        self.borders
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) const fn get_horizontals(&self) -> [(usize, HLine); HSIZE] {
+        self.horizontals
+    }
+
+    /// Builder a [`Style`]
+    #[cfg(feature = "std")]
+    pub fn build(self) -> Style {
+        let mut style = Style::new();
+        style.set_borders(self.borders);
+
+        if !self.horizontals.is_empty() {
+            let lines = self.horizontals.iter().cloned().collect();
+            style.set_lines_horizontal(lines);
+        }
+
+        if !self.verticals.is_empty() {
+            let lines = self.verticals.iter().cloned().collect();
+            style.set_lines_vertical(lines);
+        }
+
+        style
+    }
 }
 
-impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V, HN, VN> {
+impl<T, B, L, R, H, V, const HN: usize, const VN: usize> StyleBuilder<T, B, L, R, H, V, HN, VN> {
     /// Set border horizontal lines.
     ///
     /// # Example
     ///
     #[cfg_attr(feature = "derive", doc = "```")]
     #[cfg_attr(not(feature = "derive"), doc = "```ignore")]
-    /// use tabled::{settings::style::{Style, HorizontalLine, Line}, Table};
+    /// use tabled::{settings::style::{StyleBuilder, HorizontalLine}, Table};
     ///
     /// let data = (0..3).map(|i| ("Hello", i));
+    /// let mut table = Table::new(data);
     ///
-    /// let style = Style::rounded().horizontals([
+    /// let style = StyleBuilder::rounded().horizontals([
     ///     (1, HorizontalLine::filled('#')),
     ///     (2, HorizontalLine::filled('&')),
     ///     (3, HorizontalLine::filled('@')),
     /// ]);
     ///
-    /// let table = Table::new(data).with(style).to_string();
+    /// table.with(style);
     ///
     /// assert_eq!(
-    ///     table,
+    ///     table.to_string(),
     ///     concat!(
     ///         "╭───────┬─────╮\n",
     ///         "│ &str  │ i32 │\n",
@@ -520,9 +541,10 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     /// ```
     pub const fn horizontals<const SIZE: usize>(
         self,
-        list: HArray<L, R, V, SIZE>,
-    ) -> Style<T, B, L, R, H, V, SIZE, VN> {
-        Style::new(self.borders, list, self.verticals)
+        list: [(usize, HorizontalLine<L, R, V>); SIZE],
+    ) -> StyleBuilder<T, B, L, R, H, V, SIZE, VN> {
+        let list = harr_convert(list);
+        StyleBuilder::new(self.borders, list, self.verticals)
     }
 
     /// Set border vertical lines.
@@ -531,16 +553,16 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     ///
     #[cfg_attr(feature = "derive", doc = "```")]
     #[cfg_attr(not(feature = "derive"), doc = "```ignore")]
-    /// use tabled::{settings::style::{Style, VerticalLine, Line}, Table};
+    /// use tabled::{settings::style::{StyleBuilder, VerticalLine}, Table};
     ///
     /// let data = (0..3).map(|i| ("Hello", "World", i));
+    /// let mut table = Table::new(data);
     ///
-    /// let style = Style::rounded().verticals([
+    /// let style = StyleBuilder::rounded().verticals([
     ///     (1, VerticalLine::new('#').top(':').bottom('.')),
     ///     (2, VerticalLine::new('&').top(':').bottom('.')),
     /// ]);
-    ///
-    /// let table = Table::new(data).with(style).to_string();
+    /// let table = table.with(style).to_string();
     ///
     /// assert_eq!(
     ///     table,
@@ -557,25 +579,26 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     /// ```
     pub const fn verticals<const SIZE: usize>(
         self,
-        list: VArray<T, B, H, SIZE>,
-    ) -> Style<T, B, L, R, H, V, HN, SIZE> {
-        Style::new(self.borders, self.horizontals, list)
+        list: [(usize, VerticalLine<T, B, H>); SIZE],
+    ) -> StyleBuilder<T, B, L, R, H, V, HN, SIZE> {
+        let list = varr_convert(list);
+        StyleBuilder::new(self.borders, self.horizontals, list)
     }
 
-    /// Removes all horizontal lines set by [`Style::horizontals`]
-    pub const fn remove_horizontals(self) -> Style<T, B, L, R, H, V, 0, VN> {
-        Style::new(self.borders, [], self.verticals)
+    /// Removes all horizontal lines set by [`StyleBuilder::horizontals`]
+    pub const fn remove_horizontals(self) -> StyleBuilder<T, B, L, R, H, V, 0, VN> {
+        StyleBuilder::new(self.borders, [], self.verticals)
     }
 
-    /// Removes all verticals lines set by [`Style::verticals`]
-    pub const fn remove_verticals(self) -> Style<T, B, L, R, H, V, HN, 0> {
-        Style::new(self.borders, self.horizontals, [])
+    /// Removes all verticals lines set by [`StyleBuilder::verticals`]
+    pub const fn remove_verticals(self) -> StyleBuilder<T, B, L, R, H, V, HN, 0> {
+        StyleBuilder::new(self.borders, self.horizontals, [])
     }
 
     /// Sets a top border.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn top(mut self, c: char) -> Style<On, B, L, R, H, V, HN, VN>
+    pub const fn top(mut self, c: char) -> StyleBuilder<On, B, L, R, H, V, HN, VN>
     where
         T: Copy,
         B: Copy,
@@ -595,19 +618,15 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.top_intersection = Some(c);
         }
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_set(lines, Line::new(None, None, Some(c), None));
-            linearr_convert_to_varray(lines)
-        };
+        let verticals = varr_set(self.verticals, VLine::new(None, None, Some(c), None));
 
-        Style::new(self.borders, self.horizontals, verticals)
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 
     /// Sets a bottom border.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn bottom(mut self, c: char) -> Style<T, On, L, R, H, V, HN, VN>
+    pub const fn bottom(mut self, c: char) -> StyleBuilder<T, On, L, R, H, V, HN, VN>
     where
         T: Copy,
         B: Copy,
@@ -627,19 +646,15 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.bottom_intersection = Some(c);
         }
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_set(lines, Line::new(None, None, None, Some(c)));
-            linearr_convert_to_varray(lines)
-        };
+        let verticals = varr_set(self.verticals, VLine::new(None, None, None, Some(c)));
 
-        Style::new(self.borders, self.horizontals, verticals)
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 
     /// Sets a left border.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn left(mut self, c: char) -> Style<T, B, On, R, H, V, HN, VN>
+    pub const fn left(mut self, c: char) -> StyleBuilder<T, B, On, R, H, V, HN, VN>
     where
         L: Copy,
         R: Copy,
@@ -659,19 +674,15 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.left_intersection = Some(c);
         }
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_set(lines, Line::new(None, None, Some(c), None));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_set(self.horizontals, HLine::new(None, None, Some(c), None));
 
-        Style::new(self.borders, horizontals, self.verticals)
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 
     /// Sets a right border.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn right(mut self, c: char) -> Style<T, B, L, On, H, V, HN, VN>
+    pub const fn right(mut self, c: char) -> StyleBuilder<T, B, L, On, H, V, HN, VN>
     where
         L: Copy,
         R: Copy,
@@ -691,19 +702,15 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.right_intersection = Some(c);
         }
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_set(lines, Line::new(None, None, None, Some(c)));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_set(self.horizontals, HLine::new(None, None, None, Some(c)));
 
-        Style::new(self.borders, horizontals, self.verticals)
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 
     /// Sets a horizontal split line.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn horizontal(mut self, c: char) -> Style<T, B, L, R, On, V, HN, VN>
+    pub const fn horizontal(mut self, c: char) -> StyleBuilder<T, B, L, R, On, V, HN, VN>
     where
         T: Copy,
         B: Copy,
@@ -723,19 +730,15 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.right_intersection = Some(c);
         }
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_set(lines, Line::new(None, Some(c), None, None));
-            linearr_convert_to_varray(lines)
-        };
+        let verticals = varr_set(self.verticals, VLine::new(None, Some(c), None, None));
 
-        Style::new(self.borders, self.horizontals, verticals)
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 
     /// Sets a vertical split line.
     ///
     /// Any corners and intersections which were set will be overridden.
-    pub const fn vertical(mut self, c: char) -> Style<T, B, L, R, H, On, HN, VN>
+    pub const fn vertical(mut self, c: char) -> StyleBuilder<T, B, L, R, H, On, HN, VN>
     where
         L: Copy,
         R: Copy,
@@ -755,13 +758,9 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             self.borders.bottom_intersection = Some(c);
         }
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_set(lines, Line::new(None, Some(c), None, None));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_set(self.horizontals, HLine::new(None, Some(c), None, None));
 
-        Style::new(self.borders, horizontals, self.verticals)
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 
     /// Set a vertical line.
@@ -769,10 +768,10 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     ///
     /// Notice, that it will clear everything that is outdated, meaning
     /// If your style has a top border line and but the given vertical line has not got it then it will be removed.
-    pub const fn vertical_line<Top, Bottom, Intersection>(
+    pub const fn line_vertical<Top, Bottom, Intersection>(
         mut self,
         line: VerticalLine<Top, Bottom, Intersection>,
-    ) -> Style<Top, Bottom, L, R, Intersection, On, HN, VN>
+    ) -> StyleBuilder<Top, Bottom, L, R, Intersection, On, HN, VN>
     where
         L: Copy,
         R: Copy,
@@ -784,8 +783,8 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
 
         self.borders.vertical = line.main;
         self.borders.intersection = line.intersection;
-        self.borders.top_intersection = line.connector1;
-        self.borders.bottom_intersection = line.connector2;
+        self.borders.top_intersection = line.top;
+        self.borders.bottom_intersection = line.bottom;
 
         if line.intersection.is_none() {
             self.borders.horizontal = None;
@@ -806,36 +805,30 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             }
         }
 
-        if line.connector1.is_none() {
+        if line.top.is_none() {
             self.borders.top = None;
             self.borders.top_left = None;
             self.borders.top_right = None;
             self.borders.top_intersection = None;
-        } else if self.borders.has_top() && self.borders.top_intersection.is_none() {
-            self.borders.top_intersection = Some(' ');
         }
 
-        if line.connector2.is_none() {
+        if line.bottom.is_none() {
             self.borders.bottom = None;
             self.borders.bottom_left = None;
             self.borders.bottom_right = None;
             self.borders.bottom_intersection = None;
-        } else if self.borders.has_bottom() && self.borders.bottom_intersection.is_none() {
-            self.borders.bottom_intersection = Some(' ');
         }
 
-        let horizontals = harray_convert(self.horizontals);
-        let horizontals = linearr_set(horizontals, Line::new(None, line.intersection, None, None));
-        let horizontals = linearr_convert_to_harray(horizontals);
-
-        let verticals = varray_convert(self.verticals);
-        let verticals = linearr_set(
-            verticals,
-            Line::new(None, line.intersection, line.connector1, line.connector2),
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, None, None),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, line.top, line.bottom),
         );
-        let verticals = linearr_convert_to_varray(verticals);
 
-        Style::new(self.borders, horizontals, verticals)
+        StyleBuilder::new(self.borders, horizontals, verticals)
     }
 
     /// Set a horizontal line.
@@ -843,10 +836,10 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     ///
     /// Notice, that it will clear everything that is outdated, meaning
     /// If your style has a left border line and but the given vertical line has not got it then it will be removed.
-    pub const fn horizontal_line<Left, Right, Intersection>(
+    pub const fn line_horizontal<Left, Right, Intersection>(
         mut self,
         line: HorizontalLine<Left, Right, Intersection>,
-    ) -> Style<Left, Right, L, R, Intersection, On, HN, VN>
+    ) -> StyleBuilder<T, B, Left, Right, On, Intersection, HN, VN>
     where
         L: Copy,
         R: Copy,
@@ -858,8 +851,8 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
 
         self.borders.horizontal = line.main;
         self.borders.intersection = line.intersection;
-        self.borders.left_intersection = line.connector1;
-        self.borders.right_intersection = line.connector2;
+        self.borders.left_intersection = line.left;
+        self.borders.right_intersection = line.right;
 
         if line.intersection.is_none() {
             self.borders.vertical = None;
@@ -880,36 +873,302 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
             }
         }
 
-        if line.connector1.is_none() {
+        if line.left.is_none() {
             self.borders.left = None;
             self.borders.top_left = None;
             self.borders.bottom_left = None;
             self.borders.left_intersection = None;
-        } else if self.borders.has_left() && self.borders.left_intersection.is_none() {
-            self.borders.left_intersection = Some(' ');
         }
 
-        if line.connector2.is_none() {
+        if line.right.is_none() {
             self.borders.right = None;
             self.borders.top_right = None;
             self.borders.bottom_right = None;
             self.borders.right_intersection = None;
-        } else if self.borders.has_right() && self.borders.right_intersection.is_none() {
-            self.borders.right_intersection = Some(' ');
         }
 
-        let horizontals = harray_convert(self.horizontals);
-        let horizontals = linearr_set(
-            horizontals,
-            Line::new(None, line.intersection, line.connector1, line.connector2),
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, line.left, line.right),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, None, None),
+        );
+
+        StyleBuilder::new(self.borders, horizontals, verticals)
+    }
+
+    /// Set a horizontal line.
+    /// An equvalent of calling top+cornet_top_right+cornet_top_left+top_intersection.
+    ///
+    /// Notice, that it will clear everything that is outdated, meaning
+    /// If your style has a left border line and but the given vertical line has not got it then it will be removed.
+    pub const fn line_top<Left, Right, Intersection>(
+        mut self,
+        line: HorizontalLine<Left, Right, Intersection>,
+    ) -> StyleBuilder<On, B, Left, Right, H, Intersection, HN, VN>
+    where
+        L: Copy,
+        R: Copy,
+        Left: Copy,
+        Right: Copy,
+        Intersection: Copy,
+    {
+        let line = line.into_inner();
+
+        self.borders.top = line.main;
+        self.borders.top_intersection = line.intersection;
+        self.borders.top_left = line.left;
+        self.borders.top_right = line.right;
+
+        if line.intersection.is_none() {
+            self.borders.vertical = None;
+            self.borders.top_intersection = None;
+            self.borders.bottom_intersection = None;
+            self.borders.intersection = None;
+        } else {
+            if self.borders.has_top() && self.borders.top_intersection.is_none() {
+                self.borders.top_intersection = Some(' ');
+            }
+
+            if self.borders.has_bottom() && self.borders.bottom_intersection.is_none() {
+                self.borders.bottom_intersection = Some(' ');
+            }
+
+            if self.borders.vertical.is_none() {
+                self.borders.vertical = Some(' ');
+            }
+        }
+
+        if line.left.is_none() {
+            self.borders.left = None;
+            self.borders.top_left = None;
+            self.borders.bottom_left = None;
+            self.borders.left_intersection = None;
+        }
+
+        if line.right.is_none() {
+            self.borders.right = None;
+            self.borders.top_right = None;
+            self.borders.bottom_right = None;
+            self.borders.right_intersection = None;
+        }
+
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, line.left, line.right),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, None, None),
+        );
+
+        StyleBuilder::new(self.borders, horizontals, verticals)
+    }
+
+    /// Set a horizontal line.
+    /// An equvalent of calling bottom+cornet_bottom_right+cornet_bottom_left+bottom_intersection.
+    ///
+    /// Notice, that it will clear everything that is outdated, meaning
+    /// If your style has a left border line and but the given vertical line has not got it then it will be removed.
+    pub const fn line_bottom<Left, Right, Intersection>(
+        mut self,
+        line: HorizontalLine<Left, Right, Intersection>,
+    ) -> StyleBuilder<T, On, Left, Right, H, Intersection, HN, VN>
+    where
+        L: Copy,
+        R: Copy,
+        Left: Copy,
+        Right: Copy,
+        Intersection: Copy,
+    {
+        let line = line.into_inner();
+
+        self.borders.bottom = line.main;
+        self.borders.bottom_intersection = line.intersection;
+        self.borders.bottom_left = line.left;
+        self.borders.bottom_right = line.right;
+
+        if line.intersection.is_none() {
+            self.borders.vertical = None;
+            self.borders.top_intersection = None;
+            self.borders.bottom_intersection = None;
+            self.borders.intersection = None;
+        } else {
+            if self.borders.has_top() && self.borders.top_intersection.is_none() {
+                self.borders.top_intersection = Some(' ');
+            }
+
+            if self.borders.has_bottom() && self.borders.bottom_intersection.is_none() {
+                self.borders.bottom_intersection = Some(' ');
+            }
+
+            if self.borders.vertical.is_none() {
+                self.borders.vertical = Some(' ');
+            }
+        }
+
+        if line.left.is_none() {
+            self.borders.left = None;
+            self.borders.top_left = None;
+            self.borders.bottom_left = None;
+            self.borders.left_intersection = None;
+        }
+
+        if line.right.is_none() {
+            self.borders.right = None;
+            self.borders.top_right = None;
+            self.borders.bottom_right = None;
+            self.borders.right_intersection = None;
+        }
+
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, line.left, line.right),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, None, None),
+        );
+
+        StyleBuilder::new(self.borders, horizontals, verticals)
+    }
+
+    /// Set a vertical line.
+    /// An equvalent of calling left+corner_top_left+corner_bottom_left+left_intersection.
+    ///
+    /// Notice, that it will clear everything that is outdated, meaning
+    /// If your style has a top border line and but the given vertical line has not got it then it will be removed.
+    pub const fn line_left<Top, Bottom, Intersection>(
+        mut self,
+        line: VerticalLine<Top, Bottom, Intersection>,
+    ) -> StyleBuilder<Top, Bottom, On, R, Intersection, V, HN, VN>
+    where
+        L: Copy,
+        R: Copy,
+        Top: Copy,
+        Bottom: Copy,
+        Intersection: Copy,
+    {
+        let line = line.into_inner();
+
+        self.borders.left = line.main;
+        self.borders.left_intersection = line.intersection;
+        self.borders.top_left = line.top;
+        self.borders.bottom_left = line.bottom;
+
+        if line.intersection.is_none() {
+            self.borders.horizontal = None;
+            self.borders.left_intersection = None;
+            self.borders.right_intersection = None;
+            self.borders.intersection = None;
+        } else {
+            if self.borders.has_left() && self.borders.left_intersection.is_none() {
+                self.borders.left_intersection = Some(' ');
+            }
+
+            if self.borders.has_right() && self.borders.right_intersection.is_none() {
+                self.borders.right_intersection = Some(' ');
+            }
+
+            if self.borders.horizontal.is_none() {
+                self.borders.horizontal = Some(' ');
+            }
+        }
+
+        if line.top.is_none() {
+            self.borders.top = None;
+            self.borders.top_left = None;
+            self.borders.top_right = None;
+            self.borders.top_intersection = None;
+        }
+
+        if line.bottom.is_none() {
+            self.borders.bottom = None;
+            self.borders.bottom_left = None;
+            self.borders.bottom_right = None;
+            self.borders.bottom_intersection = None;
+        }
+
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, None, None),
         );
-        let horizontals = linearr_convert_to_harray(horizontals);
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, line.top, line.bottom),
+        );
+
+        StyleBuilder::new(self.borders, horizontals, verticals)
+    }
+
+    /// Set a vertical line.
+    /// An equvalent of calling right+corner_top_right+corner_bottom_right+right_intersection.
+    ///
+    /// Notice, that it will clear everything that is outdated, meaning
+    /// If your style has a top border line and but the given vertical line has not got it then it will be removed.
+    pub const fn line_right<Top, Bottom, Intersection>(
+        mut self,
+        line: VerticalLine<Top, Bottom, Intersection>,
+    ) -> StyleBuilder<Top, Bottom, L, On, Intersection, V, HN, VN>
+    where
+        L: Copy,
+        R: Copy,
+        Top: Copy,
+        Bottom: Copy,
+        Intersection: Copy,
+    {
+        let line = line.into_inner();
+
+        self.borders.right = line.main;
+        self.borders.right_intersection = line.intersection;
+        self.borders.top_right = line.top;
+        self.borders.bottom_right = line.bottom;
+
+        if line.intersection.is_none() {
+            self.borders.horizontal = None;
+            self.borders.left_intersection = None;
+            self.borders.right_intersection = None;
+            self.borders.intersection = None;
+        } else {
+            if self.borders.has_left() && self.borders.left_intersection.is_none() {
+                self.borders.left_intersection = Some(' ');
+            }
+
+            if self.borders.has_right() && self.borders.right_intersection.is_none() {
+                self.borders.right_intersection = Some(' ');
+            }
+
+            if self.borders.horizontal.is_none() {
+                self.borders.horizontal = Some(' ');
+            }
+        }
 
-        let verticals = varray_convert(self.verticals);
-        let verticals = linearr_set(verticals, Line::new(None, line.intersection, None, None));
-        let verticals = linearr_convert_to_varray(verticals);
+        if line.top.is_none() {
+            self.borders.top = None;
+            self.borders.top_left = None;
+            self.borders.top_right = None;
+            self.borders.top_intersection = None;
+        }
 
-        Style::new(self.borders, horizontals, verticals)
+        if line.bottom.is_none() {
+            self.borders.bottom = None;
+            self.borders.bottom_left = None;
+            self.borders.bottom_right = None;
+            self.borders.bottom_intersection = None;
+        }
+
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, line.intersection, None, None),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, line.intersection, line.top, line.bottom),
+        );
+
+        StyleBuilder::new(self.borders, horizontals, verticals)
     }
 
     /// Set a frame for a style.
@@ -919,11 +1178,11 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     /// # Example
     ///
     /// ```
-    /// use tabled::{Table, settings::Style};
+    /// use tabled::{Table, settings::style::{StyleBuilder, Border}};
     ///
     /// let data = [["10:52:19", "Hello"], ["10:52:20", "World"]];
     /// let table = Table::new(data)
-    ///     .with(Style::ascii().frame(Style::modern().get_frame()))
+    ///     .with(StyleBuilder::ascii().frame(Border::inherit(StyleBuilder::modern())))
     ///     .to_string();
     ///
     /// assert_eq!(
@@ -939,12 +1198,10 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
     ///     )
     /// );
     /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
     pub const fn frame<Top, Bottom, Left, Right>(
         mut self,
         border: Border<Top, Bottom, Left, Right>,
-    ) -> Style<Top, Bottom, Left, Right, H, V, HN, VN>
+    ) -> StyleBuilder<Top, Bottom, Left, Right, H, V, HN, VN>
     where
         T: Copy,
         B: Copy,
@@ -960,16 +1217,14 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
         let border = border.into_inner();
         let border = correct_border(border);
 
-        let horizontals = harray_convert(self.horizontals);
-        let horizontals = linearr_set(
-            horizontals,
-            Line::new(None, None, border.left, border.right),
+        let horizontals = harr_set(
+            self.horizontals,
+            HLine::new(None, None, border.left, border.right),
+        );
+        let verticals = varr_set(
+            self.verticals,
+            VLine::new(None, None, border.top, border.bottom),
         );
-        let horizontals = linearr_convert_to_harray(horizontals);
-
-        let verticals = varray_convert(self.verticals);
-        let verticals = linearr_set(verticals, Line::new(None, None, border.top, border.bottom));
-        let verticals = linearr_convert_to_varray(verticals);
 
         self.borders.top = border.top;
         self.borders.bottom = border.bottom;
@@ -980,151 +1235,83 @@ impl<T, B, L, R, H, V, const HN: usize, const VN: usize> Style<T, B, L, R, H, V,
         self.borders.top_right = border.right_top_corner;
         self.borders.bottom_right = border.right_bottom_corner;
 
-        Style::new(self.borders, horizontals, verticals)
+        StyleBuilder::new(self.borders, horizontals, verticals)
     }
 }
 
-impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
-    Style<T, B, L, R, H, V, HSIZE, VSIZE>
-{
-    /// Frame function returns a frame as a border.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use tabled::{Table, settings::Style};
-    ///
-    /// let data = [["10:52:19", "Hello"], ["10:52:20", "World"]];
-    /// let table = Table::new(data)
-    ///     .with(Style::re_structured_text().frame(Style::modern().get_frame()))
-    ///     .to_string();
-    ///
-    /// assert_eq!(
-    ///     table,
-    ///     concat!(
-    ///         "┌────────── ───────┐\n",
-    ///         "│ 0          1     │\n",
-    ///         "│========== =======│\n",
-    ///         "│ 10:52:19   Hello │\n",
-    ///         "│ 10:52:20   World │\n",
-    ///         "└────────── ───────┘",
-    ///     )
-    /// );
-    /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    pub const fn get_frame(&self) -> Border<T, B, L, R> {
-        crate::settings::Border::from_border(crate::grid::config::Border {
-            top: self.borders.top,
-            bottom: self.borders.bottom,
-            left: self.borders.left,
-            left_top_corner: self.borders.top_left,
-            left_bottom_corner: self.borders.bottom_left,
-            right: self.borders.right,
-            right_top_corner: self.borders.top_right,
-            right_bottom_corner: self.borders.bottom_right,
-        })
-    }
-
-    /// Return borders of a table.
-    pub const fn get_borders(&self) -> &Borders<char> {
-        &self.borders
-    }
-
-    /// Return custom horizontals which were set.
-    pub const fn get_horizontals(&self) -> HArray<L, R, V, HSIZE>
-    where
-        L: Copy,
-        R: Copy,
-        V: Copy,
-    {
-        self.horizontals
-    }
-
-    /// Return custom verticals which were set.
-    pub const fn get_verticals(&self) -> VArray<T, B, H, VSIZE>
-    where
-        T: Copy,
-        B: Copy,
-        H: Copy,
-    {
-        self.verticals
-    }
-}
-
-impl<B, R, H, V, const HN: usize, const VN: usize> Style<On, B, On, R, H, V, HN, VN> {
+impl<B, R, H, V, const HN: usize, const VN: usize> StyleBuilder<On, B, On, R, H, V, HN, VN> {
     /// Sets a top left corner.
     pub const fn corner_top_left(mut self, c: char) -> Self {
         self.borders.top_left = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<B, L, H, V, const HN: usize, const VN: usize> Style<On, B, L, On, H, V, HN, VN> {
+impl<B, L, H, V, const HN: usize, const VN: usize> StyleBuilder<On, B, L, On, H, V, HN, VN> {
     /// Sets a top right corner.
     pub const fn corner_top_right(mut self, c: char) -> Self {
         self.borders.top_right = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, L, H, V, const HN: usize, const VN: usize> Style<T, On, L, On, H, V, HN, VN> {
+impl<T, L, H, V, const HN: usize, const VN: usize> StyleBuilder<T, On, L, On, H, V, HN, VN> {
     /// Sets a bottom right corner.
     pub const fn corner_bottom_right(mut self, c: char) -> Self {
         self.borders.bottom_right = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, R, H, V, const HN: usize, const VN: usize> Style<T, On, On, R, H, V, HN, VN> {
+impl<T, R, H, V, const HN: usize, const VN: usize> StyleBuilder<T, On, On, R, H, V, HN, VN> {
     /// Sets a bottom left corner.
     pub const fn corner_bottom_left(mut self, c: char) -> Self {
         self.borders.bottom_left = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, B, R, V, const HN: usize, const VN: usize> Style<T, B, On, R, On, V, HN, VN> {
+impl<T, B, R, V, const HN: usize, const VN: usize> StyleBuilder<T, B, On, R, On, V, HN, VN> {
     /// Sets a left intersection char.
     pub const fn intersection_left(mut self, c: char) -> Self {
         self.borders.left_intersection = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, B, L, V, const HN: usize, const VN: usize> Style<T, B, L, On, On, V, HN, VN> {
+impl<T, B, L, V, const HN: usize, const VN: usize> StyleBuilder<T, B, L, On, On, V, HN, VN> {
     /// Sets a right intersection char.
     pub const fn intersection_right(mut self, c: char) -> Self {
         self.borders.right_intersection = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<B, L, R, H, const HN: usize, const VN: usize> Style<On, B, L, R, H, On, HN, VN> {
+impl<B, L, R, H, const HN: usize, const VN: usize> StyleBuilder<On, B, L, R, H, On, HN, VN> {
     /// Sets a top intersection char.
     pub const fn intersection_top(mut self, c: char) -> Self {
         self.borders.top_intersection = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, L, R, H, const HN: usize, const VN: usize> Style<T, On, L, R, H, On, HN, VN> {
+impl<T, L, R, H, const HN: usize, const VN: usize> StyleBuilder<T, On, L, R, H, On, HN, VN> {
     /// Sets a bottom intersection char.
     pub const fn intersection_bottom(mut self, c: char) -> Self {
         self.borders.bottom_intersection = Some(c);
 
-        Style::new(self.borders, self.horizontals, self.verticals)
+        StyleBuilder::new(self.borders, self.horizontals, self.verticals)
     }
 }
 
-impl<T, B, L, R, const HN: usize, const VN: usize> Style<T, B, L, R, On, On, HN, VN> {
+impl<T, B, L, R, const HN: usize, const VN: usize> StyleBuilder<T, B, L, R, On, On, HN, VN> {
     /// Sets an inner intersection char.
     /// A char between horizontal and vertical split lines.
     pub const fn intersection(mut self, c: char) -> Self
@@ -1136,25 +1323,16 @@ impl<T, B, L, R, const HN: usize, const VN: usize> Style<T, B, L, R, On, On, HN,
     {
         self.borders.intersection = Some(c);
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_set(lines, Line::new(None, Some(c), None, None));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_set(self.horizontals, HLine::new(None, Some(c), None, None));
+        let verticals = varr_set(self.verticals, VLine::new(None, Some(c), None, None));
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_set(lines, Line::new(None, Some(c), None, None));
-            linearr_convert_to_varray(lines)
-        };
-
-        Style::new(self.borders, horizontals, verticals)
+        StyleBuilder::new(self.borders, horizontals, verticals)
     }
 }
 
-impl<B, L, R, H, V, const HN: usize, const VN: usize> Style<On, B, L, R, H, V, HN, VN> {
+impl<B, L, R, H, V, const HN: usize, const VN: usize> StyleBuilder<On, B, L, R, H, V, HN, VN> {
     /// Removes top border.
-    pub const fn remove_top(mut self) -> Style<(), B, L, R, H, V, HN, VN>
+    pub const fn remove_top(mut self) -> StyleBuilder<(), B, L, R, H, V, HN, VN>
     where
         B: Copy,
         H: Copy,
@@ -1164,19 +1342,15 @@ impl<B, L, R, H, V, const HN: usize, const VN: usize> Style<On, B, L, R, H, V, H
         self.borders.top_left = None;
         self.borders.top_right = None;
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_unset(lines, Line::new(None, None, Some(' '), None));
-            linearr_convert_to_varray(lines)
-        };
+        let verticals = varr_unset(self.verticals, VLine::new(None, None, Some(' '), None));
 
-        Style::new(self.borders, self.horizontals, verticals)
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 }
 
-impl<T, L, R, H, V, const HN: usize, const VN: usize> Style<T, On, L, R, H, V, HN, VN> {
+impl<T, L, R, H, V, const HN: usize, const VN: usize> StyleBuilder<T, On, L, R, H, V, HN, VN> {
     /// Removes bottom border.
-    pub const fn remove_bottom(mut self) -> Style<T, (), L, R, H, V, HN, VN>
+    pub const fn remove_bottom(mut self) -> StyleBuilder<T, (), L, R, H, V, HN, VN>
     where
         T: Copy,
         H: Copy,
@@ -1186,19 +1360,15 @@ impl<T, L, R, H, V, const HN: usize, const VN: usize> Style<T, On, L, R, H, V, H
         self.borders.bottom_left = None;
         self.borders.bottom_right = None;
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            let lines = linearr_unset(lines, Line::new(None, None, None, Some(' ')));
-            linearr_convert_to_varray(lines)
-        };
+        let verticals = varr_unset(self.verticals, VLine::new(None, None, None, Some(' ')));
 
-        Style::new(self.borders, self.horizontals, verticals)
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 }
 
-impl<T, B, R, H, V, const HN: usize, const VN: usize> Style<T, B, On, R, H, V, HN, VN> {
+impl<T, B, R, H, V, const HN: usize, const VN: usize> StyleBuilder<T, B, On, R, H, V, HN, VN> {
     /// Removes left border.
-    pub const fn remove_left(mut self) -> Style<T, B, (), R, H, V, HN, VN>
+    pub const fn remove_left(mut self) -> StyleBuilder<T, B, (), R, H, V, HN, VN>
     where
         R: Copy,
         V: Copy,
@@ -1208,19 +1378,15 @@ impl<T, B, R, H, V, const HN: usize, const VN: usize> Style<T, B, On, R, H, V, H
         self.borders.top_left = None;
         self.borders.bottom_left = None;
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_unset(lines, Line::new(None, None, Some(' '), None));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_unset(self.horizontals, HLine::new(None, None, Some(' '), None));
 
-        Style::new(self.borders, horizontals, self.verticals)
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 }
 
-impl<T, B, L, H, V, const HN: usize, const VN: usize> Style<T, B, L, On, H, V, HN, VN> {
+impl<T, B, L, H, V, const HN: usize, const VN: usize> StyleBuilder<T, B, L, On, H, V, HN, VN> {
     /// Removes right border.
-    pub const fn remove_right(mut self) -> Style<T, B, L, (), H, V, HN, VN>
+    pub const fn remove_right(mut self) -> StyleBuilder<T, B, L, (), H, V, HN, VN>
     where
         L: Copy,
         V: Copy,
@@ -1230,21 +1396,17 @@ impl<T, B, L, H, V, const HN: usize, const VN: usize> Style<T, B, L, On, H, V, H
         self.borders.top_right = None;
         self.borders.bottom_right = None;
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            let lines = linearr_unset(lines, Line::new(None, None, None, Some(' ')));
-            linearr_convert_to_harray(lines)
-        };
+        let horizontals = harr_unset(self.horizontals, HLine::new(None, None, None, Some(' ')));
 
-        Style::new(self.borders, horizontals, self.verticals)
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 }
 
-impl<T, B, L, R, V, const HN: usize, const VN: usize> Style<T, B, L, R, On, V, HN, VN> {
+impl<T, B, L, R, V, const HN: usize, const VN: usize> StyleBuilder<T, B, L, R, On, V, HN, VN> {
     /// Removes horizontal split lines.
     ///
     /// Not including custom split lines.
-    pub const fn remove_horizontal(mut self) -> Style<T, B, L, R, (), V, HN, VN>
+    pub const fn remove_horizontal(mut self) -> StyleBuilder<T, B, L, R, (), V, HN, VN>
     where
         T: Copy,
         B: Copy,
@@ -1255,56 +1417,16 @@ impl<T, B, L, R, V, const HN: usize, const VN: usize> Style<T, B, L, R, On, V, H
         self.borders.right_intersection = None;
         self.borders.intersection = None;
 
-        let verticals = {
-            let lines = varray_convert(self.verticals);
-            // let lines = linearr_unset(lines, Line::new(None, Some(' '), None, None));
-            linearr_convert_to_varray(lines)
-        };
+        // let lines = linearr_unset(lines, Line::new(None, Some(' '), None, None));
+        let verticals = self.verticals;
 
-        Style::new(self.borders, self.horizontals, verticals)
-    }
-
-    /// Get a [`Style`]'s default horizontal line.
-    ///
-    /// It doesn't return an overloaded line via [`Style::horizontals`].
-    ///
-    /// # Example
-    ///
-    #[cfg_attr(feature = "std", doc = "```")]
-    #[cfg_attr(not(feature = "std"), doc = "```ignore")]
-    /// use tabled::{settings::style::{Style, HorizontalLine, Line}, Table};
-    ///
-    /// let data = (0..3).map(|i| ("Hello", "World", i));
-    /// let table = Table::new(data)
-    ///    .with(Style::ascii().remove_horizontal().horizontals([(1, Style::modern().get_horizontal_line())]))
-    ///    .to_string();
-    ///
-    /// assert_eq!(
-    ///     table,
-    ///     concat!(
-    ///         "+-------+-------+-----+\n",
-    ///         "| &str  | &str  | i32 |\n",
-    ///         "├───────┼───────┼─────┤\n",
-    ///         "| Hello | World | 0   |\n",
-    ///         "| Hello | World | 1   |\n",
-    ///         "| Hello | World | 2   |\n",
-    ///         "+-------+-------+-----+",
-    ///     )
-    /// )
-    /// ```
-    pub const fn get_horizontal_line(&self) -> HorizontalLine<L, R, V> {
-        HorizontalLine::update(Line::new(
-            self.borders.horizontal,
-            self.borders.intersection,
-            self.borders.left_intersection,
-            self.borders.right_intersection,
-        ))
+        StyleBuilder::new(self.borders, self.horizontals, verticals)
     }
 }
 
-impl<T, B, L, R, H, const HN: usize, const VN: usize> Style<T, B, L, R, H, On, HN, VN> {
+impl<T, B, L, R, H, const HN: usize, const VN: usize> StyleBuilder<T, B, L, R, H, On, HN, VN> {
     /// Removes vertical split lines.
-    pub const fn remove_vertical(mut self) -> Style<T, B, L, R, H, (), HN, VN>
+    pub const fn remove_vertical(mut self) -> StyleBuilder<T, B, L, R, H, (), HN, VN>
     where
         R: Copy,
         L: Copy,
@@ -1314,122 +1436,56 @@ impl<T, B, L, R, H, const HN: usize, const VN: usize> Style<T, B, L, R, H, On, H
         self.borders.bottom_intersection = None;
         self.borders.intersection = None;
 
-        let horizontals = {
-            let lines = harray_convert(self.horizontals);
-            // let lines = linearr_unset(lines, Line::new(None, Some(' '), None, None));
-            linearr_convert_to_harray(lines)
-        };
+        // let lines = linearr_unset(lines, Line::new(None, Some(' '), None, None));
+        let horizontals = self.horizontals;
 
-        Style::new(self.borders, horizontals, self.verticals)
-    }
-
-    /// Get a [`Style`]'s default horizontal line.
-    ///
-    /// It doesn't return an overloaded line via [`Style::verticals`].
-    ///
-    /// # Example
-    ///
-    #[cfg_attr(feature = "std", doc = "```")]
-    #[cfg_attr(not(feature = "std"), doc = "```ignore")]
-    /// use tabled::{settings::style::{Style, VerticalLine, Line}, Table};
-    ///
-    /// let table = Table::new((0..3).map(|i| ("Hello", "World", i)))
-    ///    .with(Style::ascii().remove_horizontal().verticals([(1, Style::modern().get_vertical_line().remove_intersection())]))
-    ///    .to_string();
-    ///
-    /// assert_eq!(
-    ///     table,
-    ///     concat!(
-    ///         "+-------┬-------+-----+\n",
-    ///         "| &str  │ &str  | i32 |\n",
-    ///         "| Hello │ World | 0   |\n",
-    ///         "| Hello │ World | 1   |\n",
-    ///         "| Hello │ World | 2   |\n",
-    ///         "+-------┴-------+-----+",
-    ///     )
-    /// )
-    /// ```
-    pub const fn get_vertical_line(&self) -> VerticalLine<T, B, H> {
-        VerticalLine::update(Line::new(
-            self.borders.vertical,
-            self.borders.intersection,
-            self.borders.top_intersection,
-            self.borders.bottom_intersection,
-        ))
+        StyleBuilder::new(self.borders, horizontals, self.verticals)
     }
 }
 
 #[cfg(feature = "std")]
 impl<T, B, L, R, H, V, Data, Dims, const HSIZE: usize, const VSIZE: usize>
-    TableOption<Data, Dims, ColoredConfig> for Style<T, B, L, R, H, V, HSIZE, VSIZE>
+    TableOption<Data, Dims, ColoredConfig> for StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>
 {
     fn change(self, _: &mut Data, cfg: &mut ColoredConfig, _: &mut Dims) {
         cfg.clear_theme();
         cfg.set_borders(self.borders);
 
         for (i, line) in self.horizontals {
-            let line = line.into_inner().into();
             cfg.insert_horizontal_line(i, line);
         }
 
         for (i, line) in self.verticals {
-            let line = line.into_inner().into();
             cfg.insert_vertical_line(i, line);
         }
     }
 }
 
 impl<T, B, L, R, H, V, Data, Dims, const HSIZE: usize, const VSIZE: usize>
-    TableOption<Data, Dims, CompactConfig> for Style<T, B, L, R, H, V, HSIZE, VSIZE>
+    TableOption<Data, Dims, CompactConfig> for StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>
 {
     fn change(self, _: &mut Data, cfg: &mut CompactConfig, _: &mut Dims) {
         *cfg = cfg.set_borders(self.borders);
-
-        if let Some((i, line)) = self.horizontals.get(0) {
-            if *i == 1 {
-                let line = line.into_inner().into();
-                *cfg = cfg.set_first_horizontal_line(line);
-            }
-        }
     }
 }
 
 impl<T, B, L, R, H, V, Data, Dims, const HSIZE: usize, const VSIZE: usize>
-    TableOption<Data, Dims, CompactMultilineConfig> for Style<T, B, L, R, H, V, HSIZE, VSIZE>
+    TableOption<Data, Dims, CompactMultilineConfig>
+    for StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>
 {
-    fn change(self, records: &mut Data, cfg: &mut CompactMultilineConfig, dims: &mut Dims) {
-        self.change(records, cfg.as_mut(), dims)
+    fn change(self, _: &mut Data, cfg: &mut CompactMultilineConfig, _: &mut Dims) {
+        cfg.set_borders(self.borders);
     }
 }
 
-const fn create_borders(
-    top: Line,
-    bottom: Line,
-    horizontal: Line,
-    left: Option<char>,
-    right: Option<char>,
-    vertical: Option<char>,
-) -> Borders<char> {
-    Borders {
-        top: top.main,
-        bottom: bottom.main,
-        top_left: top.connector1,
-        top_right: top.connector2,
-        bottom_left: bottom.connector1,
-        bottom_right: bottom.connector2,
-        top_intersection: top.intersection,
-        bottom_intersection: bottom.intersection,
-        left_intersection: horizontal.connector1,
-        right_intersection: horizontal.connector2,
-        horizontal: horizontal.main,
-        intersection: horizontal.intersection,
-        left,
-        right,
-        vertical,
+impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
+    From<StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>> for Borders<char>
+{
+    fn from(value: StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>) -> Self {
+        value.borders
     }
 }
 
-#[cfg(feature = "std")]
 const fn correct_border(mut border: GridBorder<char>) -> GridBorder<char> {
     if border.has_top() && border.top.is_none() {
         border.top = Some(' ');
@@ -1466,8 +1522,10 @@ const fn correct_border(mut border: GridBorder<char>) -> GridBorder<char> {
     border
 }
 
-const fn varray_convert<T, B, I, const N: usize>(lines: VArray<T, B, I, N>) -> [(usize, Line); N] {
-    let mut buf = [(0, Line::empty()); N];
+const fn varr_convert<T, B, I, const N: usize>(
+    lines: [(usize, VerticalLine<T, B, I>); N],
+) -> VArray<N> {
+    let mut buf = [(0, VLine::empty()); N];
     let mut i = 0;
     while i < N {
         let (index, line) = &lines[i];
@@ -1483,8 +1541,10 @@ const fn varray_convert<T, B, I, const N: usize>(lines: VArray<T, B, I, N>) -> [
     buf
 }
 
-const fn harray_convert<L, R, I, const N: usize>(lines: HArray<L, R, I, N>) -> [(usize, Line); N] {
-    let mut buf = [(0, Line::empty()); N];
+const fn harr_convert<L, R, I, const N: usize>(
+    lines: [(usize, HorizontalLine<L, R, I>); N],
+) -> HArray<N> {
+    let mut buf = [(0, HLine::empty()); N];
     let mut i = 0;
     while i < N {
         let (index, line) = &lines[i];
@@ -1500,19 +1560,27 @@ const fn harray_convert<L, R, I, const N: usize>(lines: HArray<L, R, I, N>) -> [
     buf
 }
 
-const fn linearr_convert_to_varray<T, B, I, const N: usize>(
-    lines: [(usize, Line); N],
-) -> VArray<T, B, I, N>
-where
-    T: Copy,
-    B: Copy,
-    I: Copy,
-{
-    let mut buf = [(0, VerticalLine::empty()); N];
+const fn harr_set<const N: usize>(lines: HArray<N>, set: HLine) -> HArray<N> {
+    let mut buf = [(0, HLine::empty()); N];
     let mut i = 0;
     while i < N {
-        let (index, line) = lines[i];
-        let line = VerticalLine::update(line);
+        let (index, mut line) = lines[i];
+
+        if set.left.is_some() {
+            line.left = set.left;
+        }
+
+        if set.right.is_some() {
+            line.right = set.right;
+        }
+
+        if set.intersection.is_some() {
+            line.intersection = set.intersection;
+        }
+
+        if set.main.is_some() {
+            line.main = set.main;
+        }
 
         buf[i].0 = index;
         buf[i].1 = line;
@@ -1523,19 +1591,27 @@ where
     buf
 }
 
-const fn linearr_convert_to_harray<L, R, I, const N: usize>(
-    lines: [(usize, Line); N],
-) -> HArray<L, R, I, N>
-where
-    L: Copy,
-    R: Copy,
-    I: Copy,
-{
-    let mut buf = [(0, HorizontalLine::empty()); N];
+const fn harr_unset<const N: usize>(lines: HArray<N>, set: HLine) -> HArray<N> {
+    let mut buf = [(0, HLine::empty()); N];
     let mut i = 0;
     while i < N {
-        let (index, line) = lines[i];
-        let line = HorizontalLine::update(line);
+        let (index, mut line) = lines[i];
+
+        if set.left.is_some() {
+            line.left = None;
+        }
+
+        if set.right.is_some() {
+            line.right = None;
+        }
+
+        if set.intersection.is_some() {
+            line.intersection = None;
+        }
+
+        if set.main.is_some() {
+            line.main = None;
+        }
 
         buf[i].0 = index;
         buf[i].1 = line;
@@ -1546,18 +1622,18 @@ where
     buf
 }
 
-const fn linearr_set<const N: usize>(lines: [(usize, Line); N], set: Line) -> [(usize, Line); N] {
-    let mut buf = [(0, Line::empty()); N];
+const fn varr_set<const N: usize>(lines: VArray<N>, set: VLine) -> VArray<N> {
+    let mut buf = [(0, VLine::empty()); N];
     let mut i = 0;
     while i < N {
         let (index, mut line) = lines[i];
 
-        if set.connector1.is_some() {
-            line.connector1 = set.connector1;
+        if set.top.is_some() {
+            line.top = set.top;
         }
 
-        if set.connector2.is_some() {
-            line.connector2 = set.connector2;
+        if set.bottom.is_some() {
+            line.bottom = set.bottom;
         }
 
         if set.intersection.is_some() {
@@ -1577,18 +1653,18 @@ const fn linearr_set<const N: usize>(lines: [(usize, Line); N], set: Line) -> [(
     buf
 }
 
-const fn linearr_unset<const N: usize>(lines: [(usize, Line); N], set: Line) -> [(usize, Line); N] {
-    let mut buf = [(0, Line::empty()); N];
+const fn varr_unset<const N: usize>(lines: VArray<N>, set: VLine) -> VArray<N> {
+    let mut buf = [(0, VLine::empty()); N];
     let mut i = 0;
     while i < N {
         let (index, mut line) = lines[i];
 
-        if set.connector1.is_some() {
-            line.connector1 = None;
+        if set.top.is_some() {
+            line.top = None;
         }
 
-        if set.connector2.is_some() {
-            line.connector2 = None;
+        if set.bottom.is_some() {
+            line.bottom = None;
         }
 
         if set.intersection.is_some() {
@@ -1608,4 +1684,29 @@ const fn linearr_unset<const N: usize>(lines: [(usize, Line); N], set: Line) ->
     buf
 }
 
-// todo: MACROS to reduce duplication of the same code for Varray and Harray
+const fn create_borders(
+    top: HLine,
+    bottom: HLine,
+    horizontal: HLine,
+    left: Option<char>,
+    right: Option<char>,
+    vertical: Option<char>,
+) -> Borders<char> {
+    Borders {
+        top: top.main,
+        top_left: top.left,
+        top_right: top.right,
+        top_intersection: top.intersection,
+        bottom: bottom.main,
+        bottom_left: bottom.left,
+        bottom_right: bottom.right,
+        bottom_intersection: bottom.intersection,
+        left_intersection: horizontal.left,
+        right_intersection: horizontal.right,
+        horizontal: horizontal.main,
+        intersection: horizontal.intersection,
+        left,
+        right,
+        vertical,
+    }
+}
diff --git a/tabled/src/settings/style/horizontal_line.rs b/tabled/src/settings/style/horizontal_line.rs
index 297eb32..aa27c5b 100644
--- a/tabled/src/settings/style/horizontal_line.rs
+++ b/tabled/src/settings/style/horizontal_line.rs
@@ -1,11 +1,16 @@
 use core::marker::PhantomData;
 
-use crate::settings::style::{Line, On};
+use papergrid::config::VerticalLine;
+
+use crate::grid::config::HorizontalLine as Line;
+use crate::settings::style::On;
+
+use super::StyleBuilder;
 
 /// A horizontal split line which can be used to set a border.
 #[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct HorizontalLine<L, R, I> {
-    line: Line,
+    line: Line<char>,
     _left: PhantomData<L>,
     _right: PhantomData<R>,
     _intersection: PhantomData<I>,
@@ -14,36 +19,67 @@ pub struct HorizontalLine<L, R, I> {
 impl HorizontalLine<(), (), ()> {
     /// Creates a new horizontal split line.
     pub const fn new(main: char) -> Self {
-        Self {
-            line: Line::new(Some(main), None, None, None),
-            _left: PhantomData,
-            _right: PhantomData,
-            _intersection: PhantomData,
-        }
+        Self::update(Line::new(Some(main), None, None, None))
     }
 }
 
 impl<L, R, I> HorizontalLine<L, R, I> {
     /// Creates a stub horizontal line.
     pub const fn empty() -> Self {
-        Self {
-            line: Line::new(None, None, None, None),
-            _left: PhantomData,
-            _right: PhantomData,
-            _intersection: PhantomData,
-        }
+        Self::update(Line::new(None, None, None, None))
+    }
+
+    /// Fetches vertical line from a style.
+    pub const fn inherit<T, B, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, B, L, R, I, On, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.horizontal,
+            borders.intersection,
+            borders.left_intersection,
+            borders.right_intersection,
+        );
+
+        Self::update(line)
+    }
+
+    /// Fetches left vertical line from a style.
+    pub const fn inherit_top<T, B, H, V, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<On, B, L, R, H, I, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.top,
+            borders.top_intersection,
+            borders.top_left,
+            borders.top_right,
+        );
+
+        Self::update(line)
+    }
+
+    /// Fetches right vertical line from a style.
+    pub const fn inherit_bottom<T, B, H, V, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, On, L, R, I, V, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.bottom,
+            borders.bottom_intersection,
+            borders.bottom_left,
+            borders.bottom_right,
+        );
+
+        Self::update(line)
     }
 }
 
 impl HorizontalLine<On, On, On> {
     /// Creates a new horizontal split line.
-    pub const fn full(main: char, left: char, right: char, intersection: char) -> Self {
-        Self {
-            line: Line::new(Some(main), Some(intersection), Some(left), Some(right)),
-            _left: PhantomData,
-            _right: PhantomData,
-            _intersection: PhantomData,
-        }
+    pub const fn full(main: char, intersection: char, left: char, right: char) -> Self {
+        let line = Line::new(Some(main), Some(intersection), Some(left), Some(right));
+        Self::update(line)
     }
 
     /// Creates a new horizontal split line.
@@ -53,7 +89,7 @@ impl HorizontalLine<On, On, On> {
 }
 
 impl<L, R, I> HorizontalLine<L, R, I> {
-    pub(crate) const fn update(line: Line) -> HorizontalLine<L, R, I> {
+    pub(crate) const fn update(line: Line<char>) -> HorizontalLine<L, R, I> {
         Self {
             line,
             _left: PhantomData,
@@ -76,13 +112,13 @@ impl<L, R, I> HorizontalLine<L, R, I> {
 
     /// Set a left character.
     pub const fn left(mut self, c: char) -> HorizontalLine<On, R, I> {
-        self.line.connector1 = Some(c);
+        self.line.left = Some(c);
         HorizontalLine::update(self.line)
     }
 
     /// Set a right character.
     pub const fn right(mut self, c: char) -> HorizontalLine<L, On, I> {
-        self.line.connector2 = Some(c);
+        self.line.right = Some(c);
         HorizontalLine::update(self.line)
     }
 }
@@ -90,14 +126,11 @@ impl<L, R, I> HorizontalLine<L, R, I> {
 impl<L, R, I> HorizontalLine<L, R, I> {
     /// Get a horizontal character.
     pub const fn get_horizontal(&self) -> char {
-        match self.line.main {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.main)
     }
 
     /// Get a general structure of line.
-    pub const fn into_inner(&self) -> Line {
+    pub const fn into_inner(&self) -> Line<char> {
         self.line
     }
 }
@@ -105,10 +138,7 @@ impl<L, R, I> HorizontalLine<L, R, I> {
 impl<L, R> HorizontalLine<L, R, On> {
     /// Set a vertical intersection character.
     pub const fn get_intersection(&self) -> char {
-        match self.line.intersection {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.intersection)
     }
 
     /// Remove a vertical intersection character.
@@ -121,15 +151,12 @@ impl<L, R> HorizontalLine<L, R, On> {
 impl<R, I> HorizontalLine<On, R, I> {
     /// Get a left character.
     pub const fn get_left(&self) -> char {
-        match self.line.connector1 {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.left)
     }
 
     /// Remove a horizontal left character.
     pub const fn remove_left(mut self) -> HorizontalLine<(), R, I> {
-        self.line.connector1 = None;
+        self.line.left = None;
         HorizontalLine::update(self.line)
     }
 }
@@ -137,21 +164,44 @@ impl<R, I> HorizontalLine<On, R, I> {
 impl<L, I> HorizontalLine<L, On, I> {
     /// Get a right character.
     pub const fn get_right(&self) -> char {
-        match self.line.connector2 {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.right)
     }
 
     /// Remove a horizontal right character.
     pub const fn remove_right(mut self) -> HorizontalLine<I, (), I> {
-        self.line.connector2 = None;
+        self.line.right = None;
         HorizontalLine::update(self.line)
     }
 }
 
-impl<L, R, I> From<HorizontalLine<L, R, I>> for Line {
+impl<L, R, I> From<HorizontalLine<L, R, I>> for Line<char> {
     fn from(value: HorizontalLine<L, R, I>) -> Self {
         value.line
     }
 }
+
+impl<L, R, I> From<Line<char>> for HorizontalLine<L, R, I> {
+    fn from(value: Line<char>) -> Self {
+        let mut line = Self::empty();
+        line.line = value;
+        line
+    }
+}
+
+impl<T, B, I> From<HorizontalLine<T, B, I>> for VerticalLine<char> {
+    fn from(value: HorizontalLine<T, B, I>) -> Self {
+        VerticalLine::new(
+            value.line.main,
+            value.line.intersection,
+            value.line.left,
+            value.line.right,
+        )
+    }
+}
+
+const fn opt_get(opt: Option<char>) -> char {
+    match opt {
+        Some(value) => value,
+        None => unreachable!(),
+    }
+}
diff --git a/tabled/src/settings/style/line.rs b/tabled/src/settings/style/line.rs
deleted file mode 100644
index b1eaabb..0000000
--- a/tabled/src/settings/style/line.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-#[cfg(feature = "std")]
-use crate::grid::config::{HorizontalLine, VerticalLine};
-
-/// The structure represent a vertical or horizontal line.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Line {
-    pub(crate) main: Option<char>,
-    pub(crate) intersection: Option<char>,
-    pub(crate) connector1: Option<char>,
-    pub(crate) connector2: Option<char>,
-}
-
-impl Line {
-    /// Creates a new [`Line`] object.
-    pub const fn new(
-        main: Option<char>,
-        intersection: Option<char>,
-        connector1: Option<char>,
-        connector2: Option<char>,
-    ) -> Self {
-        Self {
-            main,
-            intersection,
-            connector1,
-            connector2,
-        }
-    }
-
-    /// Creates a new [`Line`] object with all chars set.
-    pub const fn full(main: char, intersection: char, connector1: char, connector2: char) -> Self {
-        Self::new(
-            Some(main),
-            Some(intersection),
-            Some(connector1),
-            Some(connector2),
-        )
-    }
-
-    /// Creates a new [`Line`] object with all chars set to the provided one.
-    pub const fn filled(c: char) -> Self {
-        Self::full(c, c, c, c)
-    }
-
-    /// Creates a new [`Line`] object with all chars not set.
-    pub const fn empty() -> Self {
-        Self::new(None, None, None, None)
-    }
-
-    /// Checks if the line has nothing set.
-    pub const fn is_empty(&self) -> bool {
-        self.main.is_none()
-            && self.intersection.is_none()
-            && self.connector1.is_none()
-            && self.connector2.is_none()
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<Line> for HorizontalLine {
-    fn from(l: Line) -> Self {
-        Self {
-            main: l.main,
-            intersection: l.intersection,
-            left: l.connector1,
-            right: l.connector2,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<HorizontalLine> for Line {
-    fn from(l: HorizontalLine) -> Self {
-        Self {
-            main: l.main,
-            intersection: l.intersection,
-            connector1: l.left,
-            connector2: l.right,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<Line> for VerticalLine {
-    fn from(l: Line) -> Self {
-        Self {
-            main: l.main,
-            intersection: l.intersection,
-            top: l.connector1,
-            bottom: l.connector2,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<VerticalLine> for Line {
-    fn from(l: VerticalLine) -> Self {
-        Self {
-            main: l.main,
-            intersection: l.intersection,
-            connector1: l.top,
-            connector2: l.bottom,
-        }
-    }
-}
-
-impl From<Line> for papergrid::config::Line<char> {
-    fn from(l: Line) -> Self {
-        Self {
-            main: l.main.unwrap_or(' '),
-            intersection: l.intersection,
-            connect1: l.connector1,
-            connect2: l.connector2,
-        }
-    }
-}
diff --git a/tabled/src/settings/style/mod.rs b/tabled/src/settings/style/mod.rs
index aa9b07e..0c08e94 100644
--- a/tabled/src/settings/style/mod.rs
+++ b/tabled/src/settings/style/mod.rs
@@ -94,8 +94,12 @@
 //! [`BorderText`]: crate::settings::style::BorderText
 //! [`RawStyle`]: crate::settings::style::RawStyle
 
-#[cfg(feature = "std")]
 mod border;
+mod builder;
+mod horizontal_line;
+mod offset;
+mod vertical_line;
+
 #[cfg(feature = "std")]
 mod border_color;
 #[cfg(feature = "std")]
@@ -103,25 +107,22 @@ mod border_text;
 #[cfg(feature = "std")]
 mod line_char;
 #[cfg(feature = "std")]
-mod offset;
-#[cfg(feature = "std")]
-mod raw_style;
-#[cfg(feature = "std")]
 mod span_border_correction;
-
-mod builder;
-mod horizontal_line;
-mod line;
-mod vertical_line;
+#[cfg(feature = "std")]
+#[allow(clippy::module_inception)]
+mod style;
 
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 pub use self::{
-    border::Border, border_color::BorderColor, border_text::LineText, line_char::LineChar,
-    offset::Offset, raw_style::RawStyle, span_border_correction::BorderSpanCorrection,
+    border_color::BorderColor, border_text::LineText, line_char::LineChar,
+    span_border_correction::BorderSpanCorrection, style::Style,
 };
 
-pub use builder::{On, Style};
-pub use horizontal_line::HorizontalLine;
-pub use line::Line;
-pub use vertical_line::VerticalLine;
+pub use self::{
+    border::Border,
+    builder::{On, StyleBuilder},
+    horizontal_line::HorizontalLine,
+    offset::Offset,
+    vertical_line::VerticalLine,
+};
diff --git a/tabled/src/settings/style/offset.rs b/tabled/src/settings/style/offset.rs
index 0ea6783..375b9b5 100644
--- a/tabled/src/settings/style/offset.rs
+++ b/tabled/src/settings/style/offset.rs
@@ -1,3 +1,4 @@
+#[cfg(feature = "std")]
 use crate::grid::config;
 
 /// The structure represents an offset in a text.
@@ -9,6 +10,7 @@ pub enum Offset {
     End(usize),
 }
 
+#[cfg(feature = "std")]
 impl From<Offset> for config::Offset {
     fn from(o: Offset) -> Self {
         match o {
diff --git a/tabled/src/settings/style/raw_style.rs b/tabled/src/settings/style/raw_style.rs
deleted file mode 100644
index ce71093..0000000
--- a/tabled/src/settings/style/raw_style.rs
+++ /dev/null
@@ -1,463 +0,0 @@
-//! This module contains [`RawStyle`] structure, which is analogues to [`Style`] but not generic,
-//! so sometimes it can be used more conviently.
-
-use std::collections::HashMap;
-
-use crate::{
-    grid::{
-        color::AnsiColor,
-        config::{self, Border, Borders, ColoredConfig},
-        records::Records,
-    },
-    settings::{Color, TableOption},
-};
-
-use super::{Line, Style};
-
-/// A raw style data, which can be produced safely from [`Style`].
-///
-/// It can be useful in order to not have a generics and be able to use it as a variable more conveniently.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RawStyle {
-    borders: Borders<char>,
-    colors: Borders<AnsiColor<'static>>,
-    horizontals: HashMap<usize, Line>,
-    verticals: HashMap<usize, Line>,
-}
-
-impl RawStyle {
-    /// Set a top border character.
-    pub fn set_top(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.top = s;
-        self
-    }
-
-    /// Set a top border color.
-    pub fn set_color_top(&mut self, color: Color) -> &mut Self {
-        self.colors.top = Some(color.into());
-        self
-    }
-
-    /// Set a bottom border character.
-    pub fn set_bottom(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.bottom = s;
-        self
-    }
-
-    /// Set a bottom border color.
-    pub fn set_color_bottom(&mut self, color: Color) -> &mut Self {
-        self.colors.bottom = Some(color.into());
-        self
-    }
-
-    /// Set a left border character.
-    pub fn set_left(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.left = s;
-        self
-    }
-
-    /// Set a left border color.
-    pub fn set_color_left(&mut self, color: Color) -> &mut Self {
-        self.colors.left = Some(color.into());
-        self
-    }
-
-    /// Set a right border character.
-    pub fn set_right(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.right = s;
-        self
-    }
-
-    /// Set a right border color.
-    pub fn set_color_right(&mut self, color: Color) -> &mut Self {
-        self.colors.right = Some(color.into());
-        self
-    }
-
-    /// Set a top intersection character.
-    pub fn set_intersection_top(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.top_intersection = s;
-        self
-    }
-
-    /// Set a top intersection color.
-    pub fn set_color_intersection_top(&mut self, color: Color) -> &mut Self {
-        self.colors.top_intersection = Some(color.into());
-        self
-    }
-
-    /// Set a bottom intersection character.
-    pub fn set_intersection_bottom(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.bottom_intersection = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_intersection_bottom(&mut self, color: Color) -> &mut Self {
-        self.colors.bottom_intersection = Some(color.into());
-        self
-    }
-
-    /// Set a left split character.
-    pub fn set_intersection_left(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.left_intersection = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_intersection_left(&mut self, color: Color) -> &mut Self {
-        self.colors.left_intersection = Some(color.into());
-        self
-    }
-
-    /// Set a right split character.
-    pub fn set_intersection_right(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.right_intersection = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_intersection_right(&mut self, color: Color) -> &mut Self {
-        self.colors.right_intersection = Some(color.into());
-        self
-    }
-
-    /// Set an internal character.
-    pub fn set_intersection(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.intersection = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_intersection(&mut self, color: Color) -> &mut Self {
-        self.colors.intersection = Some(color.into());
-        self
-    }
-
-    /// Set a vertical character.
-    pub fn set_vertical(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.vertical = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_vertical(&mut self, color: Color) -> &mut Self {
-        self.colors.vertical = Some(color.into());
-        self
-    }
-
-    /// Set a horizontal character.
-    pub fn set_horizontal(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.horizontal = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_horizontal(&mut self, color: Color) -> &mut Self {
-        self.colors.horizontal = Some(color.into());
-        self
-    }
-
-    /// Set a character for a top left corner.
-    pub fn set_corner_top_left(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.top_left = s;
-        self
-    }
-    /// Set a bottom intersection color.
-    pub fn set_color_corner_top_left(&mut self, color: Color) -> &mut Self {
-        self.colors.top_left = Some(color.into());
-        self
-    }
-
-    /// Set a character for a top right corner.
-    pub fn set_corner_top_right(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.top_right = s;
-        self
-    }
-
-    /// Set a bottom intersection color.
-    pub fn set_color_corner_top_right(&mut self, color: Color) -> &mut Self {
-        self.colors.top_right = Some(color.into());
-        self
-    }
-
-    /// Set a character for a bottom left corner.
-    pub fn set_corner_bottom_left(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.bottom_left = s;
-        self
-    }
-    /// Set a bottom intersection color.
-    pub fn set_color_corner_bottom_left(&mut self, color: Color) -> &mut Self {
-        self.colors.bottom_left = Some(color.into());
-        self
-    }
-
-    /// Set a character for a bottom right corner.
-    pub fn set_corner_bottom_right(&mut self, s: Option<char>) -> &mut Self {
-        self.borders.bottom_right = s;
-        self
-    }
-    /// Set a bottom intersection color.
-    pub fn set_color_corner_bottom_right(&mut self, color: Color) -> &mut Self {
-        self.colors.bottom_right = Some(color.into());
-        self
-    }
-
-    /// Set horizontal border lines.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::HashMap;
-    /// use tabled::{Table, settings::style::{Style, Line, RawStyle}};
-    ///
-    /// let data = (0..3).map(|i| ("Hello", i));
-    ///
-    /// let mut style = RawStyle::from(Style::re_structured_text());
-    /// let mut lines = HashMap::new();
-    /// lines.insert(1, Style::extended().get_horizontal_line().into_inner());
-    /// style.set_horizontals(lines);
-    ///
-    /// let table = Table::new(data).with(style).to_string();
-    ///
-    /// assert_eq!(
-    ///     table,
-    ///     concat!(
-    ///         " ======= ===== \n",
-    ///         "  &str    i32  \n",
-    ///         "╠═══════╬═════╣\n",
-    ///         "  Hello   0    \n",
-    ///         "  Hello   1    \n",
-    ///         "  Hello   2    \n",
-    ///         " ======= ===== ",
-    ///     ),
-    /// )
-    /// ```
-    pub fn set_horizontals(&mut self, lines: HashMap<usize, Line>) -> &mut Self {
-        self.horizontals = lines;
-        self
-    }
-
-    /// Insert a horizontal line to a specific row location.
-    pub fn insert_horizontal(&mut self, row: usize, line: Line) -> &mut Self {
-        let _ = self.horizontals.insert(row, line);
-        self
-    }
-
-    /// Insert a horizontal line to a specific row location.
-    pub fn get_horizontal(&self, row: usize) -> Option<Line> {
-        self.horizontals.get(&row).cloned()
-    }
-
-    /// Set vertical border lines.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::HashMap;
-    /// use tabled::{Table, settings::style::{Style, Line, RawStyle}};
-    ///
-    /// let data = (0..3).map(|i| ("Hello", i));
-    ///
-    /// let mut style = RawStyle::from(Style::re_structured_text());
-    /// let mut lines = HashMap::new();
-    /// lines.insert(1, Style::extended().get_horizontal_line().into_inner());
-    /// style.set_verticals(lines);
-    ///
-    /// let table = Table::new(data).with(style).to_string();
-    ///
-    /// assert_eq!(
-    ///     table,
-    ///     concat!(
-    ///         "=======╠=====\n",
-    ///         " &str  ═ i32 \n",
-    ///         "======= =====\n",
-    ///         " Hello ═ 0   \n",
-    ///         " Hello ═ 1   \n",
-    ///         " Hello ═ 2   \n",
-    ///         "=======╣=====",
-    ///     ),
-    /// )
-    /// ```
-    pub fn set_verticals(&mut self, lines: HashMap<usize, Line>) -> &mut Self {
-        self.verticals = lines;
-        self
-    }
-
-    /// Insert a vertical line into specific column location.
-    pub fn insert_vertical(&mut self, column: usize, line: Line) -> &mut Self {
-        let _ = self.verticals.insert(column, line);
-        self
-    }
-
-    /// Get a left char.
-    pub fn get_left(&self) -> Option<char> {
-        self.borders.left
-    }
-
-    /// Get a left intersection char.
-    pub fn get_left_intersection(&self) -> Option<char> {
-        self.borders.left_intersection
-    }
-
-    /// Get a right char.
-    pub fn get_right(&self) -> Option<char> {
-        self.borders.right
-    }
-
-    /// Get a right intersection char.
-    pub fn get_right_intersection(&self) -> Option<char> {
-        self.borders.right_intersection
-    }
-
-    /// Get a top char.
-    pub fn get_top(&self) -> Option<char> {
-        self.borders.top
-    }
-
-    /// Get a top left char.
-    pub fn get_top_left(&self) -> Option<char> {
-        self.borders.top_left
-    }
-
-    /// Get a top right char.
-    pub fn get_top_right(&self) -> Option<char> {
-        self.borders.top_right
-    }
-
-    /// Get a top intersection char.
-    pub fn get_top_intersection(&self) -> Option<char> {
-        self.borders.top_intersection
-    }
-
-    /// Get a bottom intersection char.
-    pub fn get_bottom(&self) -> Option<char> {
-        self.borders.bottom
-    }
-
-    /// Get a bottom intersection char.
-    pub fn get_bottom_left(&self) -> Option<char> {
-        self.borders.bottom_left
-    }
-
-    /// Get a bottom intersection char.
-    pub fn get_bottom_right(&self) -> Option<char> {
-        self.borders.bottom_right
-    }
-
-    /// Get a bottom intersection char.
-    pub fn get_bottom_intersection(&self) -> Option<char> {
-        self.borders.bottom_intersection
-    }
-
-    /// Returns an outer border of the style.
-    pub fn get_frame(&self) -> Border<char> {
-        Border {
-            top: self.borders.top,
-            bottom: self.borders.bottom,
-            left: self.borders.left,
-            right: self.borders.right,
-            left_top_corner: self.borders.top_left,
-            right_top_corner: self.borders.top_right,
-            left_bottom_corner: self.borders.bottom_left,
-            right_bottom_corner: self.borders.bottom_right,
-        }
-    }
-
-    /// Returns an general borders configuration of the style.
-    pub fn get_borders(&self) -> Borders<char> {
-        self.borders
-    }
-}
-
-impl From<Borders<char>> for RawStyle {
-    fn from(borders: Borders<char>) -> Self {
-        Self {
-            borders,
-            horizontals: HashMap::new(),
-            verticals: HashMap::new(),
-            colors: Borders::default(),
-        }
-    }
-}
-
-impl<R, D> TableOption<R, D, ColoredConfig> for RawStyle
-where
-    R: Records,
-{
-    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
-        cfg.clear_theme();
-        cfg.set_borders(self.borders);
-
-        for (&row, line) in &self.horizontals {
-            cfg.insert_horizontal_line(row, config::HorizontalLine::from(*line));
-        }
-
-        for (&col, line) in &self.verticals {
-            cfg.insert_vertical_line(col, config::VerticalLine::from(*line));
-        }
-
-        if !self.colors.is_empty() {
-            cfg.set_borders_color(self.colors.clone());
-        }
-    }
-}
-
-impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
-    From<Style<T, B, L, R, H, V, HSIZE, VSIZE>> for RawStyle
-where
-    T: Copy,
-    B: Copy,
-    L: Copy,
-    R: Copy,
-    H: Copy,
-    V: Copy,
-{
-    fn from(style: Style<T, B, L, R, H, V, HSIZE, VSIZE>) -> Self {
-        let horizontals = style
-            .get_horizontals()
-            .map(|(i, hr)| (i, hr.into_inner()))
-            .iter()
-            .cloned()
-            .collect();
-
-        let verticals = style
-            .get_verticals()
-            .map(|(i, hr)| (i, hr.into_inner()))
-            .iter()
-            .cloned()
-            .collect();
-
-        Self {
-            borders: *style.get_borders(),
-            horizontals,
-            verticals,
-            colors: Borders::default(),
-        }
-    }
-}
-
-impl From<ColoredConfig> for RawStyle {
-    fn from(cfg: ColoredConfig) -> Self {
-        let horizontals = cfg
-            .get_horizontal_lines()
-            .into_iter()
-            .map(|(i, line)| (i, line.into()))
-            .collect();
-        let verticals = cfg
-            .get_vertical_lines()
-            .into_iter()
-            .map(|(i, line)| (i, line.into()))
-            .collect();
-
-        let borders = *cfg.get_borders();
-        let colors = cfg.get_color_borders().clone();
-
-        Self {
-            borders,
-            horizontals,
-            verticals,
-            colors,
-        }
-    }
-}
diff --git a/tabled/src/settings/style/style.rs b/tabled/src/settings/style/style.rs
new file mode 100644
index 0000000..d50ea29
--- /dev/null
+++ b/tabled/src/settings/style/style.rs
@@ -0,0 +1,736 @@
+//! This module contains [`RawStyle`] structure, which is analogues to [`Style`] but not generic,
+//! so sometimes it can be used more conviently.
+
+use core::iter::FromIterator;
+use std::collections::HashMap;
+
+use papergrid::config::compact::CompactConfig;
+
+use crate::{
+    grid::{
+        color::AnsiColor,
+        config::{
+            Border, Borders, ColoredConfig, CompactMultilineConfig, HorizontalLine, VerticalLine,
+        },
+        records::Records,
+    },
+    settings::{Color, TableOption},
+};
+
+use super::StyleBuilder;
+
+/// A raw style data, which can be produced safely from [`Style`].
+///
+/// It can be useful in order to not have a generics and be able to use it as a variable more conveniently.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Style {
+    borders: Borders<char>,
+    colors: Borders<AnsiColor<'static>>,
+    horizontal1: Option<HorizontalLine<char>>,
+    horizontals: Option<HashMap<usize, HorizontalLine<char>>>,
+    verticals: Option<HashMap<usize, VerticalLine<char>>>,
+}
+
+impl Style {
+    /// This style is a style with no styling options on,
+    ///
+    /// ```text
+    ///      id  destribution            link
+    ///      0      Fedora      https://getfedora.org/
+    ///      2     OpenSUSE    https://www.opensuse.org/
+    ///      3   Endeavouros   https://endeavouros.com/
+    /// ```
+    ///
+    /// Note: The cells in the example have 1-left and 1-right indent.
+    ///
+    /// This style can be used as a base style to build a custom one.
+    ///
+    /// ```rust,no_run
+    /// # use tabled::settings::Style;
+    /// let mut style = Style::empty();
+    /// style.set_top(Some('*'));
+    /// style.set_bottom(Some('*'));
+    /// style.set_vertical(Some('#'));
+    /// style.set_intersection_top(Some('*'));
+    /// ```
+    pub const fn empty() -> Style {
+        Self::with(StyleBuilder::empty())
+    }
+
+    /// This style is analog of `empty` but with a vertical space(' ') line.
+    ///
+    /// ```text
+    ///      id   destribution             link
+    ///      0       Fedora       https://getfedora.org/
+    ///      2      OpenSUSE     https://www.opensuse.org/
+    ///      3    Endeavouros    https://endeavouros.com/
+    /// ```
+    pub const fn blank() -> Style {
+        Self::with(StyleBuilder::blank())
+    }
+
+    /// This is a style which relays only on ASCII charset.
+    ///
+    /// It has horizontal and vertical lines.
+    ///
+    /// ```text
+    ///     +----+--------------+---------------------------+
+    ///     | id | destribution |           link            |
+    ///     +----+--------------+---------------------------+
+    ///     | 0  |    Fedora    |  https://getfedora.org/   |
+    ///     +----+--------------+---------------------------+
+    ///     | 2  |   OpenSUSE   | https://www.opensuse.org/ |
+    ///     +----+--------------+---------------------------+
+    ///     | 3  | Endeavouros  | https://endeavouros.com/  |
+    ///     +----+--------------+---------------------------+
+    /// ```
+    pub const fn ascii() -> Style {
+        Self::with(StyleBuilder::ascii())
+    }
+
+    /// `psql` style looks like a table style `PostgreSQL` uses.
+    ///
+    /// It has only 1 horizontal line which splits header.
+    /// And no left and right vertical lines.
+    ///
+    /// ```text
+    ///      id | destribution |           link
+    ///     ----+--------------+---------------------------
+    ///      0  |    Fedora    |  https://getfedora.org/
+    ///      2  |   OpenSUSE   | https://www.opensuse.org/
+    ///      3  | Endeavouros  | https://endeavouros.com/
+    /// ```
+    pub const fn psql() -> Style {
+        Self::with(StyleBuilder::psql())
+    }
+
+    /// `markdown` style mimics a `Markdown` table style.
+    ///
+    /// ```text
+    ///     | id | destribution |           link            |
+    ///     |----|--------------|---------------------------|
+    ///     | 0  |    Fedora    |  https://getfedora.org/   |
+    ///     | 2  |   OpenSUSE   | https://www.opensuse.org/ |
+    ///     | 3  | Endeavouros  | https://endeavouros.com/  |
+    /// ```
+    pub const fn markdown() -> Style {
+        Self::with(StyleBuilder::markdown())
+    }
+
+    /// This style is analog of [`StyleBuilder::ascii`] which uses UTF-8 charset.
+    ///
+    /// It has vertical and horizontal split lines.
+    ///
+    /// ```text
+    ///     ┌────┬──────────────┬───────────────────────────┐
+    ///     │ id │ destribution │           link            │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 0  │    Fedora    │  https://getfedora.org/   │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 2  │   OpenSUSE   │ https://www.opensuse.org/ │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
+    ///     └────┴──────────────┴───────────────────────────┘
+    /// ```
+    pub const fn modern() -> Style {
+        Self::with(StyleBuilder::modern())
+    }
+
+    /// This style looks like a [`StyleBuilder::modern`] but without horozizontal lines except a header.
+    ///
+    /// Beware: It uses UTF-8 characters.
+    ///
+    /// ```text
+    ///     ┌────┬──────────────┬───────────────────────────┐
+    ///     │ id │ destribution │           link            │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 0  │    Fedora    │  https://getfedora.org/   │
+    ///     │ 2  │   OpenSUSE   │ https://www.opensuse.org/ │
+    ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
+    ///     └────┴──────────────┴───────────────────────────┘
+    /// ```
+    pub const fn sharp() -> Style {
+        Self::with(StyleBuilder::sharp())
+    }
+
+    /// This style looks like a [`StyleBuilder::sharp`] but with rounded corners.
+    ///
+    /// Beware: It uses UTF-8 characters.
+    ///
+    /// ```text
+    ///     ╭────┬──────────────┬───────────────────────────╮
+    ///     │ id │ destribution │           link            │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 0  │    Fedora    │  https://getfedora.org/   │
+    ///     │ 2  │   OpenSUSE   │ https://www.opensuse.org/ │
+    ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
+    ///     ╰────┴──────────────┴───────────────────────────╯
+    /// ```
+    pub const fn rounded() -> Style {
+        Self::with(StyleBuilder::rounded())
+    }
+
+    /// This style looks like a [`StyleBuilder::rounded`] but with horizontals lines.
+    ///
+    /// Beware: It uses UTF-8 characters.
+    ///
+    /// ```text
+    ///     ╭────┬──────────────┬───────────────────────────╮
+    ///     │ id │ destribution │           link            │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 0  │    Fedora    │  https://getfedora.org/   │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 2  │   OpenSUSE   │ https://www.opensuse.org/ │
+    ///     ├────┼──────────────┼───────────────────────────┤
+    ///     │ 3  │ Endeavouros  │ https://endeavouros.com/  │
+    ///     ╰────┴──────────────┴───────────────────────────╯
+    /// ```
+    pub const fn modern_rounded() -> Style {
+        Self::with(StyleBuilder::modern_rounded())
+    }
+
+    /// This style uses a chars which resembles '2 lines'.
+    ///
+    /// Beware: It uses UTF8 characters.
+    ///
+    /// ```text
+    ///     ╔════╦══════════════╦═══════════════════════════╗
+    ///     ║ id ║ destribution ║           link            ║
+    ///     ╠════╬══════════════╬═══════════════════════════╣
+    ///     ║ 0  ║    Fedora    ║  https://getfedora.org/   ║
+    ///     ╠════╬══════════════╬═══════════════════════════╣
+    ///     ║ 2  ║   OpenSUSE   ║ https://www.opensuse.org/ ║
+    ///     ╠════╬══════════════╬═══════════════════════════╣
+    ///     ║ 3  ║ Endeavouros  ║ https://endeavouros.com/  ║
+    ///     ╚════╩══════════════╩═══════════════════════════╝
+    /// ```
+    pub const fn extended() -> Style {
+        Self::with(StyleBuilder::extended())
+    }
+
+    /// This is a style uses only '.' and ':' chars.
+    /// It has a vertical and horizontal split lines.
+    ///
+    /// ```text
+    ///     .................................................
+    ///     : id : destribution :           link            :
+    ///     :....:..............:...........................:
+    ///     : 0  :    Fedora    :  https://getfedora.org/   :
+    ///     :....:..............:...........................:
+    ///     : 2  :   OpenSUSE   : https://www.opensuse.org/ :
+    ///     :....:..............:...........................:
+    ///     : 3  : Endeavouros  : https://endeavouros.com/  :
+    ///     :....:..............:...........................:
+    /// ```
+    pub const fn dots() -> Style {
+        Self::with(StyleBuilder::dots())
+    }
+
+    /// This style is one of table views in `ReStructuredText`.
+    ///
+    /// ```text
+    ///     ==== ============== ===========================
+    ///      id   destribution             link            
+    ///     ==== ============== ===========================
+    ///      0       Fedora       https://getfedora.org/   
+    ///      2      OpenSUSE     https://www.opensuse.org/
+    ///      3    Endeavouros    https://endeavouros.com/  
+    ///     ==== ============== ===========================
+    /// ```
+    pub const fn re_structured_text() -> Style {
+        Self::with(StyleBuilder::re_structured_text())
+    }
+
+    /// This is a theme analog of [`StyleBuilder::rounded`], but in using ascii charset and
+    /// with no horizontal lines.
+    ///
+    /// ```text
+    ///     .-----------------------------------------------.
+    ///     | id | destribution |           link            |
+    ///     | 0  |    Fedora    |  https://getfedora.org/   |
+    ///     | 2  |   OpenSUSE   | https://www.opensuse.org/ |
+    ///     | 3  | Endeavouros  | https://endeavouros.com/  |
+    ///     '-----------------------------------------------'
+    /// ```
+    pub const fn ascii_rounded() -> Style {
+        Self::with(StyleBuilder::ascii_rounded())
+    }
+}
+
+impl Style {
+    /// Creates a new empty style.
+    ///
+    /// It's quite an analog of [`Style::empty`]
+    pub const fn new() -> Self {
+        Self {
+            borders: Borders::empty(),
+            colors: Borders::empty(),
+            horizontal1: None,
+            horizontals: None,
+            verticals: None,
+        }
+    }
+
+    const fn with<A, B, C, D, E, J, const HS: usize, const VS: usize>(
+        builder: StyleBuilder<A, B, C, D, E, J, HS, VS>,
+    ) -> Self {
+        let borders = builder.get_borders();
+
+        let horizontals = builder.get_horizontals();
+        let mut horizontal1 = None;
+
+        let mut i = 0;
+        while i < horizontals.len() {
+            let (line, hline) = horizontals[i];
+            if line == 1 {
+                horizontal1 = Some(hline);
+            }
+
+            i += 1;
+        }
+
+        Self {
+            borders,
+            horizontal1,
+            colors: Borders::empty(),
+            horizontals: None,
+            verticals: None,
+        }
+    }
+}
+
+impl Style {
+    /// Set a top border character.
+    pub fn set_top(&mut self, s: Option<char>) {
+        self.borders.top = s
+    }
+
+    /// Set a top border color.
+    pub fn set_color_top(&mut self, color: Color) {
+        self.colors.top = Some(color.into())
+    }
+
+    /// Set a bottom border character.
+    pub fn set_bottom(&mut self, s: Option<char>) {
+        self.borders.bottom = s
+    }
+
+    /// Set a bottom border color.
+    pub fn set_color_bottom(&mut self, color: Color) {
+        self.colors.bottom = Some(color.into())
+    }
+
+    /// Set a left border character.
+    pub fn set_left(&mut self, s: Option<char>) {
+        self.borders.left = s
+    }
+
+    /// Set a left border color.
+    pub fn set_color_left(&mut self, color: Color) {
+        self.colors.left = Some(color.into())
+    }
+
+    /// Set a right border character.
+    pub fn set_right(&mut self, s: Option<char>) {
+        self.borders.right = s
+    }
+
+    /// Set a right border color.
+    pub fn set_color_right(&mut self, color: Color) {
+        self.colors.right = Some(color.into())
+    }
+
+    /// Set a top intersection character.
+    pub fn set_intersection_top(&mut self, s: Option<char>) {
+        self.borders.top_intersection = s
+    }
+
+    /// Set a top intersection color.
+    pub fn set_color_intersection_top(&mut self, color: Color) {
+        self.colors.top_intersection = Some(color.into())
+    }
+
+    /// Set a bottom intersection character.
+    pub fn set_intersection_bottom(&mut self, s: Option<char>) {
+        self.borders.bottom_intersection = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_intersection_bottom(&mut self, color: Color) {
+        self.colors.bottom_intersection = Some(color.into())
+    }
+
+    /// Set a left split character.
+    pub fn set_intersection_left(&mut self, s: Option<char>) {
+        self.borders.left_intersection = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_intersection_left(&mut self, color: Color) {
+        self.colors.left_intersection = Some(color.into())
+    }
+
+    /// Set a right split character.
+    pub fn set_intersection_right(&mut self, s: Option<char>) {
+        self.borders.right_intersection = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_intersection_right(&mut self, color: Color) {
+        self.colors.right_intersection = Some(color.into())
+    }
+
+    /// Set an internal character.
+    pub fn set_intersection(&mut self, s: Option<char>) {
+        self.borders.intersection = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_intersection(&mut self, color: Color) {
+        self.colors.intersection = Some(color.into())
+    }
+
+    /// Set a vertical character.
+    pub fn set_vertical(&mut self, s: Option<char>) {
+        self.borders.vertical = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_vertical(&mut self, color: Color) {
+        self.colors.vertical = Some(color.into())
+    }
+
+    /// Set a horizontal character.
+    pub fn set_horizontal(&mut self, s: Option<char>) {
+        self.borders.horizontal = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_horizontal(&mut self, color: Color) {
+        self.colors.horizontal = Some(color.into())
+    }
+
+    /// Set a character for a top left corner.
+    pub fn set_corner_top_left(&mut self, s: Option<char>) {
+        self.borders.top_left = s
+    }
+    /// Set a bottom intersection color.
+    pub fn set_color_corner_top_left(&mut self, color: Color) {
+        self.colors.top_left = Some(color.into())
+    }
+
+    /// Set a character for a top right corner.
+    pub fn set_corner_top_right(&mut self, s: Option<char>) {
+        self.borders.top_right = s
+    }
+
+    /// Set a bottom intersection color.
+    pub fn set_color_corner_top_right(&mut self, color: Color) {
+        self.colors.top_right = Some(color.into())
+    }
+
+    /// Set a character for a bottom left corner.
+    pub fn set_corner_bottom_left(&mut self, s: Option<char>) {
+        self.borders.bottom_left = s
+    }
+    /// Set a bottom intersection color.
+    pub fn set_color_corner_bottom_left(&mut self, color: Color) {
+        self.colors.bottom_left = Some(color.into())
+    }
+
+    /// Set a character for a bottom right corner.
+    pub fn set_corner_bottom_right(&mut self, s: Option<char>) {
+        self.borders.bottom_right = s
+    }
+    /// Set a bottom intersection color.
+    pub fn set_color_corner_bottom_right(&mut self, color: Color) {
+        self.colors.bottom_right = Some(color.into())
+    }
+
+    /// Returns an outer border of the style.
+    pub fn set_frame(&mut self, frame: Border<char>) {
+        self.borders.top = frame.top;
+        self.borders.bottom = frame.bottom;
+        self.borders.left = frame.left;
+        self.borders.right = frame.right;
+        self.borders.top_left = frame.left_top_corner;
+        self.borders.top_right = frame.right_top_corner;
+        self.borders.bottom_left = frame.left_bottom_corner;
+        self.borders.bottom_right = frame.right_bottom_corner;
+    }
+
+    /// Set borders structure.
+    pub fn set_borders(&mut self, borders: Borders<char>) {
+        self.borders = borders;
+    }
+
+    /// Set horizontal border lines.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// use tabled::{Table, settings::style::{Style, StyleBuilder, HorizontalLine}};
+    ///
+    /// let mut style = Style::re_structured_text();
+    ///
+    /// let mut lines = HashMap::new();
+    /// lines.insert(1, HorizontalLine::inherit(StyleBuilder::extended()).into());
+    ///
+    /// style.set_lines_horizontal(lines);
+    ///
+    /// let data = (0..3).map(|i| ("Hello", i));
+    /// let table = Table::new(data).with(style).to_string();
+    ///
+    /// assert_eq!(
+    ///     table,
+    ///     concat!(
+    ///         " ======= ===== \n",
+    ///         "  &str    i32  \n",
+    ///         "╠═══════╬═════╣\n",
+    ///         "  Hello   0    \n",
+    ///         "  Hello   1    \n",
+    ///         "  Hello   2    \n",
+    ///         " ======= ===== ",
+    ///     ),
+    /// )
+    /// ```
+    pub fn set_lines_horizontal(&mut self, lines: HashMap<usize, HorizontalLine<char>>) {
+        self.horizontals = Some(lines);
+    }
+
+    /// Set vertical border lines.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// use tabled::{Table, settings::style::{Style, StyleBuilder, HorizontalLine}};
+    ///
+    ///
+    /// let mut style = Style::re_structured_text();
+    ///
+    /// let mut lines = HashMap::new();
+    /// lines.insert(1, HorizontalLine::inherit(StyleBuilder::extended()).into());
+    ///
+    /// style.set_lines_vertical(lines);
+    ///
+    /// let data = (0..3).map(|i| ("Hello", i));
+    /// let table = Table::new(data).with(style).to_string();
+    ///
+    /// assert_eq!(
+    ///     table,
+    ///     concat!(
+    ///         "=======╠=====\n",
+    ///         " &str  ═ i32 \n",
+    ///         "======= =====\n",
+    ///         " Hello ═ 0   \n",
+    ///         " Hello ═ 1   \n",
+    ///         " Hello ═ 2   \n",
+    ///         "=======╣=====",
+    ///     ),
+    /// )
+    /// ```
+    pub fn set_lines_vertical(&mut self, lines: HashMap<usize, VerticalLine<char>>) {
+        self.verticals = Some(lines);
+    }
+
+    /// Insert a vertical line into specific column location.
+    pub fn insert_line_vertical(&mut self, line: usize, vertical: VerticalLine<char>) {
+        match &mut self.verticals {
+            Some(verticals) => {
+                let _ = verticals.insert(line, vertical);
+            }
+            None => self.verticals = Some(HashMap::from_iter([(line, vertical)])),
+        }
+    }
+
+    /// Insert a horizontal line to a specific row location.
+    pub fn insert_line_horizontal(&mut self, line: usize, horizontal: HorizontalLine<char>) {
+        match &mut self.horizontals {
+            Some(horizontals) => {
+                let _ = horizontals.insert(line, horizontal);
+            }
+            None => self.horizontals = Some(HashMap::from_iter([(line, horizontal)])),
+        }
+    }
+
+    /// Get a vertical line at the row if any set.
+    pub fn get_line_vertical(&self, column: usize) -> Option<VerticalLine<char>> {
+        self.verticals
+            .as_ref()
+            .and_then(|lines| lines.get(&column).cloned())
+    }
+
+    /// Get a horizontal line at the row if any set.
+    pub fn get_line_horizontal(&self, row: usize) -> Option<HorizontalLine<char>> {
+        self.horizontals
+            .as_ref()
+            .and_then(|list| list.get(&row).cloned())
+    }
+
+    /// Get a left char.
+    pub const fn get_left(&self) -> Option<char> {
+        self.borders.left
+    }
+
+    /// Get a left intersection char.
+    pub const fn get_left_intersection(&self) -> Option<char> {
+        self.borders.left_intersection
+    }
+
+    /// Get a right char.
+    pub const fn get_right(&self) -> Option<char> {
+        self.borders.right
+    }
+
+    /// Get a right intersection char.
+    pub const fn get_right_intersection(&self) -> Option<char> {
+        self.borders.right_intersection
+    }
+
+    /// Get a top char.
+    pub const fn get_top(&self) -> Option<char> {
+        self.borders.top
+    }
+
+    /// Get a top left char.
+    pub const fn get_top_left(&self) -> Option<char> {
+        self.borders.top_left
+    }
+
+    /// Get a top right char.
+    pub const fn get_top_right(&self) -> Option<char> {
+        self.borders.top_right
+    }
+
+    /// Get a top intersection char.
+    pub const fn get_top_intersection(&self) -> Option<char> {
+        self.borders.top_intersection
+    }
+
+    /// Get a bottom intersection char.
+    pub const fn get_bottom(&self) -> Option<char> {
+        self.borders.bottom
+    }
+
+    /// Get a bottom intersection char.
+    pub const fn get_bottom_left(&self) -> Option<char> {
+        self.borders.bottom_left
+    }
+
+    /// Get a bottom intersection char.
+    pub const fn get_bottom_right(&self) -> Option<char> {
+        self.borders.bottom_right
+    }
+
+    /// Get a bottom intersection char.
+    pub const fn get_bottom_intersection(&self) -> Option<char> {
+        self.borders.bottom_intersection
+    }
+
+    /// Set an outer border.
+    pub const fn get_frame(&self) -> Border<char> {
+        Border {
+            top: self.borders.top,
+            bottom: self.borders.bottom,
+            left: self.borders.left,
+            right: self.borders.right,
+            left_top_corner: self.borders.top_left,
+            right_top_corner: self.borders.top_right,
+            left_bottom_corner: self.borders.bottom_left,
+            right_bottom_corner: self.borders.bottom_right,
+        }
+    }
+
+    /// Returns an general borders configuration of the style.
+    pub const fn get_borders(&self) -> Borders<char> {
+        self.borders
+    }
+}
+
+impl From<Borders<char>> for Style {
+    fn from(borders: Borders<char>) -> Self {
+        Self {
+            borders,
+            horizontals: None,
+            verticals: None,
+            horizontal1: None,
+            colors: Borders::default(),
+        }
+    }
+}
+
+impl<R, D> TableOption<R, D, ColoredConfig> for Style
+where
+    R: Records,
+{
+    fn change(self, _: &mut R, cfg: &mut ColoredConfig, _: &mut D) {
+        cfg.clear_theme();
+        cfg.set_borders(self.borders);
+
+        if let Some(line) = self.horizontal1 {
+            cfg.insert_horizontal_line(1, line);
+        }
+
+        if let Some(lines) = self.horizontals {
+            for (row, line) in lines {
+                cfg.insert_horizontal_line(row, line);
+            }
+        }
+
+        if let Some(lines) = self.verticals {
+            for (col, line) in lines {
+                cfg.insert_vertical_line(col, line);
+            }
+        }
+
+        if !self.colors.is_empty() {
+            cfg.set_borders_color(self.colors.clone());
+        }
+    }
+}
+
+impl<R, D> TableOption<R, D, CompactConfig> for Style {
+    fn change(self, _: &mut R, cfg: &mut CompactConfig, _: &mut D) {
+        *cfg = cfg.set_borders(self.borders);
+    }
+}
+
+impl<R, D> TableOption<R, D, CompactMultilineConfig> for Style {
+    fn change(self, _: &mut R, cfg: &mut CompactMultilineConfig, _: &mut D) {
+        cfg.set_borders(self.borders);
+    }
+}
+
+impl<T, B, L, R, H, V, const HSIZE: usize, const VSIZE: usize>
+    From<StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>> for Style
+where
+    T: Copy,
+    B: Copy,
+    L: Copy,
+    R: Copy,
+    H: Copy,
+    V: Copy,
+{
+    fn from(style: StyleBuilder<T, B, L, R, H, V, HSIZE, VSIZE>) -> Self {
+        style.build()
+    }
+}
+
+impl From<ColoredConfig> for Style {
+    fn from(cfg: ColoredConfig) -> Self {
+        let borders = *cfg.get_borders();
+        let colors = cfg.get_color_borders().clone();
+        let horizontals = cfg.get_horizontal_lines().into_iter().collect();
+        let verticals = cfg.get_vertical_lines().into_iter().collect();
+
+        Self {
+            borders,
+            colors,
+            horizontal1: None,
+            horizontals: Some(horizontals),
+            verticals: Some(verticals),
+        }
+    }
+}
diff --git a/tabled/src/settings/style/vertical_line.rs b/tabled/src/settings/style/vertical_line.rs
index 0bc158f..1810c77 100644
--- a/tabled/src/settings/style/vertical_line.rs
+++ b/tabled/src/settings/style/vertical_line.rs
@@ -1,11 +1,16 @@
 use core::marker::PhantomData;
 
-use crate::settings::style::{Line, On};
+use papergrid::config::HorizontalLine;
+
+use crate::grid::config::VerticalLine as Line;
+use crate::settings::style::On;
+
+use super::StyleBuilder;
 
 /// A vertical split line which can be used to set a border.
 #[derive(Debug, Clone, Copy, Default, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct VerticalLine<T, B, I> {
-    line: Line,
+    line: Line<char>,
     _top: PhantomData<T>,
     _bottom: PhantomData<B>,
     _intersection: PhantomData<I>,
@@ -14,36 +19,71 @@ pub struct VerticalLine<T, B, I> {
 impl VerticalLine<(), (), ()> {
     /// Creates a new vertical split line.
     pub const fn new(main: char) -> Self {
-        Self {
-            line: Line::new(Some(main), None, None, None),
-            _top: PhantomData,
-            _bottom: PhantomData,
-            _intersection: PhantomData,
-        }
+        Self::update(Line::new(Some(main), None, None, None))
     }
 }
 
-impl<L, R, I> VerticalLine<L, R, I> {
+impl<T, B, I> VerticalLine<T, B, I> {
     /// Creates a stub horizontal line.
     pub const fn empty() -> Self {
-        Self {
-            line: Line::new(None, None, None, None),
-            _top: PhantomData,
-            _bottom: PhantomData,
-            _intersection: PhantomData,
-        }
+        Self::update(Line::empty())
+    }
+
+    /// Fetches vertical line from a style.
+    pub const fn inherit<L, R, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, B, L, R, I, On, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.vertical,
+            borders.intersection,
+            borders.top_intersection,
+            borders.bottom_intersection,
+        );
+
+        Self::update(line)
+    }
+
+    /// Fetches left vertical line from a style.
+    pub const fn inherit_left<R, V, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, B, On, R, I, V, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.left,
+            borders.left_intersection,
+            borders.top_left,
+            borders.bottom_left,
+        );
+
+        Self::update(line)
+    }
+
+    /// Fetches right vertical line from a style.
+    pub const fn inherit_right<L, V, const HSIZE: usize, const VSIZE: usize>(
+        style: StyleBuilder<T, B, L, On, I, V, HSIZE, VSIZE>,
+    ) -> Self {
+        let borders = style.get_borders();
+        let line = Line::new(
+            borders.right,
+            borders.right_intersection,
+            borders.top_right,
+            borders.bottom_right,
+        );
+
+        Self::update(line)
     }
 }
 
 impl VerticalLine<On, On, On> {
     /// Creates a new vertical split line.
-    pub const fn full(main: char, top: char, bottom: char, intersection: char) -> Self {
-        Self {
-            line: Line::new(Some(main), Some(intersection), Some(top), Some(bottom)),
-            _top: PhantomData,
-            _bottom: PhantomData,
-            _intersection: PhantomData,
-        }
+    pub const fn full(main: char, intersection: char, top: char, bottom: char) -> Self {
+        Self::update(Line::new(
+            Some(main),
+            Some(intersection),
+            Some(top),
+            Some(bottom),
+        ))
     }
 
     /// Creates a new vertical split line.
@@ -67,19 +107,19 @@ impl<T, B, I> VerticalLine<T, B, I> {
 
     /// Set a top character.
     pub const fn top(mut self, c: char) -> VerticalLine<On, B, I> {
-        self.line.connector1 = Some(c);
+        self.line.top = Some(c);
         VerticalLine::update(self.line)
     }
 
     /// Set a bottom character.
     pub const fn bottom(mut self, c: char) -> VerticalLine<T, On, I> {
-        self.line.connector2 = Some(c);
+        self.line.bottom = Some(c);
         VerticalLine::update(self.line)
     }
 }
 
 impl<T, B, I> VerticalLine<T, B, I> {
-    pub(crate) const fn update(line: Line) -> VerticalLine<T, B, I> {
+    pub(crate) const fn update(line: Line<char>) -> VerticalLine<T, B, I> {
         Self {
             line,
             _top: PhantomData,
@@ -97,7 +137,7 @@ impl<T, B, I> VerticalLine<T, B, I> {
     }
 
     /// Get a general structure of line.
-    pub const fn into_inner(&self) -> Line {
+    pub const fn into_inner(&self) -> Line<char> {
         self.line
     }
 }
@@ -121,15 +161,12 @@ impl<T, B> VerticalLine<T, B, On> {
 impl<B, I> VerticalLine<On, B, I> {
     /// Get a top character.
     pub const fn get_top(&self) -> char {
-        match self.line.connector1 {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.top)
     }
 
     /// Remove a vertical top character.
     pub const fn remove_top(mut self) -> VerticalLine<(), B, I> {
-        self.line.connector1 = None;
+        self.line.top = None;
         VerticalLine::update(self.line)
     }
 }
@@ -137,21 +174,44 @@ impl<B, I> VerticalLine<On, B, I> {
 impl<T, I> VerticalLine<T, On, I> {
     /// Get a bottom character.
     pub const fn get_bottom(&self) -> char {
-        match self.line.connector2 {
-            Some(c) => c,
-            None => unreachable!(),
-        }
+        opt_get(self.line.bottom)
     }
 
     /// Remove a vertical bottom character.
     pub const fn remove_bottom(mut self) -> VerticalLine<T, (), I> {
-        self.line.connector2 = None;
+        self.line.bottom = None;
         VerticalLine::update(self.line)
     }
 }
 
-impl<T, B, I> From<VerticalLine<T, B, I>> for Line {
+impl<T, B, I> From<VerticalLine<T, B, I>> for Line<char> {
     fn from(value: VerticalLine<T, B, I>) -> Self {
         value.line
     }
 }
+
+impl<T, B, I> From<VerticalLine<T, B, I>> for HorizontalLine<char> {
+    fn from(value: VerticalLine<T, B, I>) -> Self {
+        HorizontalLine::new(
+            value.line.main,
+            value.line.intersection,
+            value.line.top,
+            value.line.bottom,
+        )
+    }
+}
+
+impl<T, B, I> From<Line<char>> for VerticalLine<T, B, I> {
+    fn from(value: Line<char>) -> Self {
+        let mut line = Self::empty();
+        line.line = value;
+        line
+    }
+}
+
+const fn opt_get(opt: Option<char>) -> char {
+    match opt {
+        Some(value) => value,
+        None => unreachable!(),
+    }
+}
diff --git a/tabled/src/tables/compact.rs b/tabled/src/tables/compact.rs
index 14c1e2b..1dcfab3 100644
--- a/tabled/src/tables/compact.rs
+++ b/tabled/src/tables/compact.rs
@@ -25,7 +25,6 @@
 //!     table,
 //!     concat!(
 //!         " FreeBSD     | 1993 | William and Lynne Jolitz     | ? \n",
-//!         "-------------+------+------------------------------+---\n",
 //!         " OpenBSD     | 1995 | Theo de Raadt                |   \n",
 //!         " HardenedBSD | 2014 | Oliver Pinter and Shawn Webb |   ",
 //!     )
@@ -80,7 +79,7 @@ use crate::{
         util::string::string_width,
         CompactGrid,
     },
-    settings::{Style, TableOption},
+    settings::{style::StyleBuilder, TableOption},
 };
 
 /// A table which consumes an [`IntoRecords`] iterator.
@@ -291,7 +290,7 @@ fn build_grid<W: fmt::Write, I: IntoRecords, D: Dimension>(
 }
 
 const fn create_config() -> CompactConfig {
-    CompactConfig::empty()
+    CompactConfig::new()
         .set_padding(Sides::new(
             Indent::spaced(1),
             Indent::spaced(1),
@@ -299,7 +298,7 @@ const fn create_config() -> CompactConfig {
             Indent::zero(),
         ))
         .set_alignment_horizontal(AlignmentHorizontal::Left)
-        .set_borders(*Style::ascii().get_borders())
+        .set_borders(StyleBuilder::ascii().get_borders())
 }
 
 impl<R, D> TableOption<R, D, CompactConfig> for CompactConfig {
diff --git a/tabled/src/tables/iter.rs b/tabled/src/tables/iter.rs
index af485ac..ca7605b 100644
--- a/tabled/src/tables/iter.rs
+++ b/tabled/src/tables/iter.rs
@@ -329,7 +329,7 @@ fn create_config() -> CompactConfig {
             Indent::default(),
         ))
         .set_alignment_horizontal(AlignmentHorizontal::Left)
-        .set_borders(*Style::ascii().get_borders())
+        .set_borders(Style::ascii().get_borders())
 }
 
 fn build_records<I: IntoRecords>(
diff --git a/tabled/src/tables/mod.rs b/tabled/src/tables/mod.rs
index e0c4bf7..737afc9 100644
--- a/tabled/src/tables/mod.rs
+++ b/tabled/src/tables/mod.rs
@@ -46,3 +46,13 @@ pub use extended::ExtendedTable;
 pub use table_pool::{PoolTable, TableValue};
 
 pub use compact::CompactTable;
+
+// todo: Create a PoolTable backend in papergrid with generics so it coulb be used differently
+//       rather then with our own impl of dimension
+//
+// todo: Replace all usage of conrete configs to a AsRef<Config> generics, so some could be used interchangably
+//
+// todo: Think about all the Config hierachly; we probably shall have something like a Decorator approach there.
+//       config(borders) -> config(borders+colors) -> config(borders+colors+spans)
+//
+//       Or maybe many interfacies e.g ColorConfig, BorderConfig, AlignmentConfig etc.
diff --git a/tabled/src/tables/table.rs b/tabled/src/tables/table.rs
index 789a85f..2c448c2 100644
--- a/tabled/src/tables/table.rs
+++ b/tabled/src/tables/table.rs
@@ -413,7 +413,7 @@ fn configure_grid() -> SpannedConfig {
     );
     cfg.set_alignment_horizontal(Entity::Global, AlignmentHorizontal::Left);
     cfg.set_formatting(Entity::Global, Formatting::new(false, false, false));
-    cfg.set_borders(*Style::ascii().get_borders());
+    cfg.set_borders(Style::ascii().get_borders());
 
     cfg
 }
diff --git a/tabled/src/tables/table_pool.rs b/tabled/src/tables/table_pool.rs
index 07d2a54..6ce6bb7 100644
--- a/tabled/src/tables/table_pool.rs
+++ b/tabled/src/tables/table_pool.rs
@@ -209,14 +209,16 @@ fn configure_grid() -> CompactMultilineConfig {
     let pad = Sides::new(
         Indent::spaced(1),
         Indent::spaced(1),
-        Indent::default(),
-        Indent::default(),
+        Indent::zero(),
+        Indent::zero(),
     );
 
-    CompactMultilineConfig::default()
-        .set_padding(pad)
-        .set_alignment_horizontal(AlignmentHorizontal::Left)
-        .set_borders(*Style::ascii().get_borders())
+    let mut cfg = CompactMultilineConfig::new();
+    cfg.set_padding(pad);
+    cfg.set_alignment_horizontal(AlignmentHorizontal::Left);
+    cfg.set_borders(Style::ascii().get_borders());
+
+    cfg
 }
 
 impl<R, C> TableOption<R, PoolTableDimension, C> for PoolTableDimension {
@@ -318,7 +320,7 @@ mod print {
             || margin.left.size > 0
             || margin.right.size > 0;
         if has_margin {
-            let color = convert_border_colors(cfg.get_margin_color());
+            let color = convert_border_colors(*cfg.get_margin_color());
             table = set_margin(&table, *margin, color);
         }
 
@@ -555,8 +557,7 @@ mod print {
         let halignment = cfg.get_alignment_horizontal();
         let valignment = cfg.get_alignment_vertical();
         let pad = cfg.get_padding();
-        let pad_color = cfg.get_padding_color();
-        let pad_color = convert_border_colors(pad_color);
+        let pad_color = convert_border_colors(*cfg.get_padding_color());
         let lines_alignemnt = cfg.get_formatting().allow_lines_alignment;
 
         let mut borders = *cfg.get_borders();


Test patch:
diff --git a/papergrid/tests/grid/format_configuration.rs b/papergrid/tests/grid/format_configuration.rs
index 1abfaa3..6f37e3e 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::{spanned::Formatting, AlignmentHorizontal, AlignmentVertical, Entity};
+use papergrid::config::{AlignmentHorizontal, AlignmentVertical, Entity, Formatting};
 
 use crate::util::grid;
 use testing_table::static_table;
diff --git a/tabled/tests/core/table_test.rs b/tabled/tests/core/table_test.rs
index 517e2e2..97ad4df 100644
--- a/tabled/tests/core/table_test.rs
+++ b/tabled/tests/core/table_test.rs
@@ -343,7 +343,7 @@ mod derived {
 
     use std::collections::{BTreeMap, BTreeSet};
 
-    use tabled::Tabled;
+    use tabled::{settings::style::StyleBuilder, Tabled};
 
     #[derive(Tabled)]
     struct TestType {
@@ -566,7 +566,7 @@ mod derived {
                     invented_year: 2009,
                 },
             ]
-        }).with(Style::modern().remove_horizontal()),
+        }).with(StyleBuilder::modern().remove_horizontal()),
         // Note: It doesn't look good in VS Code
         "┌─────────┬────────────────┬───────────────┐"
         "│ name    │ designed_by    │ invented_year │"
diff --git a/tabled/tests/settings/disable_test.rs b/tabled/tests/settings/disable_test.rs
index 901998e..9ea4897 100644
--- a/tabled/tests/settings/disable_test.rs
+++ b/tabled/tests/settings/disable_test.rs
@@ -3,7 +3,7 @@
 use tabled::settings::{
     location::ByColumnName,
     object::{Columns, Rows, Segment},
-    style::Style,
+    style::{HorizontalLine, Style, StyleBuilder},
     Alignment, Disable, Modify,
 };
 
@@ -42,7 +42,7 @@ test_table!(
     Matrix::new(3, 3)
         .with(Modify::new(Segment::all()).with(Alignment::left()))
         .with(Disable::row(Rows::new(..1)))
-        .with(Style::modern().remove_horizontal().horizontals([(1, Style::modern().get_horizontal_line())])),
+        .with(StyleBuilder::modern().remove_horizontal().horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()))])),
     "┌───┬─────┬─────┬─────┐"
     "│ 0 │ 0-0 │ 0-1 │ 0-2 │"
     "├───┼─────┼─────┼─────┤"
diff --git a/tabled/tests/settings/height_test.rs b/tabled/tests/settings/height_test.rs
index 48d6a63..662150f 100644
--- a/tabled/tests/settings/height_test.rs
+++ b/tabled/tests/settings/height_test.rs
@@ -11,6 +11,9 @@ use testing_table::test_table;
 #[cfg(feature = "color")]
 use owo_colors::OwoColorize;
 
+#[cfg(feature = "macros")]
+use tabled::settings::style::StyleBuilder;
+
 test_table!(
     cell_height_increase,
     Matrix::new(3, 3)
@@ -253,7 +256,7 @@ test_table!(
 #[cfg(feature = "macros")]
 test_table!(
     cell_height_1x1_no_top_border,
-    tabled::row![tabled::col!["SGML"].with(Style::ascii().remove_top()).with(Height::increase(4))],
+    tabled::row![tabled::col!["SGML"].with(StyleBuilder::ascii().remove_top()).with(Height::increase(4))],
     "+----------+"
     "| | SGML | |"
     "| |      | |"
diff --git a/tabled/tests/settings/panel_test.rs b/tabled/tests/settings/panel_test.rs
index 1f3c242..0ee8859 100644
--- a/tabled/tests/settings/panel_test.rs
+++ b/tabled/tests/settings/panel_test.rs
@@ -1,8 +1,10 @@
 #![cfg(feature = "std")]
 
+use std::{collections::HashMap, iter::FromIterator};
+
 use tabled::settings::{
     object::{Cell, Object, Rows, Segment},
-    style::BorderSpanCorrection,
+    style::{BorderSpanCorrection, HorizontalLine, StyleBuilder},
     Alignment, Border, Highlight, Modify, Panel, Span, Style, Width,
 };
 
@@ -141,7 +143,12 @@ test_table!(
     panel_style_change,
     Matrix::iter([(0, 1)])
         .with(Panel::horizontal(0,"Numbers"))
-        .with(Style::modern().intersection_top('─').horizontals([(1, Style::modern().get_horizontal_line().intersection('┬'))]))
+        .with({
+            let mut style = Style::modern();
+            style.set_intersection_top(Some('─'));
+            style.set_lines_horizontal(HashMap::from_iter([(1,  HorizontalLine::inherit(StyleBuilder::modern()).intersection('┬').into_inner())]));
+            style
+        })
         .with(Modify::new(Cell::new(0, 0)).with(Alignment::center())),
     "┌───────────┐"
     "│  Numbers  │"
@@ -170,8 +177,8 @@ test_table!(
 test_table!(
     panel_style_change_correct,
     Matrix::iter([(0, 1)])
-        .with(Panel::horizontal(0,"Numbers"))
-        .with(Style::modern().intersection_top('─').horizontals([(1, Style::modern().get_horizontal_line().intersection('┬'))]))
+        .with(Panel::horizontal(0, "Numbers"))
+        .with(StyleBuilder::modern().intersection_top('─').horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()).intersection('┬'))]))
         .with(BorderSpanCorrection)
         .with(Modify::new(Cell::new(0, 0)).with(Alignment::center())),
     "┌───────────┐"
diff --git a/tabled/tests/settings/style_test.rs b/tabled/tests/settings/style_test.rs
index 000e66f..a8798fd 100644
--- a/tabled/tests/settings/style_test.rs
+++ b/tabled/tests/settings/style_test.rs
@@ -1,6 +1,6 @@
 #![cfg(feature = "std")]
 
-use std::{collections::HashMap, iter::FromIterator};
+use std::iter::FromIterator;
 
 use tabled::{
     builder::Builder,
@@ -8,8 +8,8 @@ use tabled::{
     settings::{
         object::{Columns, Rows, Segment},
         style::{
-            Border, BorderColor, BorderSpanCorrection, HorizontalLine, Line, LineChar, LineText,
-            Offset, On, RawStyle, Style, VerticalLine,
+            Border, BorderColor, BorderSpanCorrection, HorizontalLine, LineChar, LineText, Offset,
+            On, Style, StyleBuilder, VerticalLine,
         },
         Color, Format, Highlight, Modify, Padding, Span,
     },
@@ -110,7 +110,7 @@ test_table!(
 
 test_table!(
     modern_clean_style,
-    Matrix::new(3, 3).with(Style::modern().remove_horizontal().horizontals([(1, Style::modern().get_horizontal_line())])),
+    Matrix::new(3, 3).with(StyleBuilder::modern().remove_horizontal().horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()))])),
     "┌───┬──────────┬──────────┬──────────┐"
     "│ N │ column 0 │ column 1 │ column 2 │"
     "├───┼──────────┼──────────┼──────────┤"
@@ -182,7 +182,7 @@ test_table!(
 
 test_table!(
     style_head_changes,
-    Matrix::new(3, 3).with(Style::modern().remove_horizontal()),
+    Matrix::new(3, 3).with(StyleBuilder::modern().remove_horizontal()),
     "┌───┬──────────┬──────────┬──────────┐"
     "│ N │ column 0 │ column 1 │ column 2 │"
     "│ 0 │   0-0    │   0-1    │   0-2    │"
@@ -193,7 +193,7 @@ test_table!(
 
 test_table!(
     style_frame_changes,
-    Matrix::new(3, 3).with(Style::modern().remove_top().remove_bottom().remove_horizontal()),
+    Matrix::new(3, 3).with(StyleBuilder::modern().remove_top().remove_bottom().remove_horizontal()),
     "│ N │ column 0 │ column 1 │ column 2 │"
     "│ 0 │   0-0    │   0-1    │   0-2    │"
     "│ 1 │   1-0    │   1-1    │   1-2    │"
@@ -203,7 +203,7 @@ test_table!(
 test_table!(
     custom_style,
     Matrix::new(3, 3)
-        .with(Style::blank()
+        .with(StyleBuilder::blank()
             .bottom('*')
             .vertical('\'')
             .horizontal('`')
@@ -536,7 +536,7 @@ test_table!(
 
 test_table!(
     style_frame_test_0,
-    Matrix::table(2, 2).with(Highlight::border(Rows::single(1), Style::modern().get_frame())),
+    Matrix::table(2, 2).with(Highlight::border(Rows::single(1), Border::inherit(StyleBuilder::modern()))),
     "+---+----------+----------+"
     "| N | column 0 | column 1 |"
     "┌─────────────────────────┐"
@@ -550,8 +550,8 @@ test_table!(
     style_frame_test_1,
     Matrix::table(2, 2)
         .with(Style::blank())
-        .with(Highlight::border(Rows::single(0), Style::extended().get_frame()))
-        .with(Highlight::border(Rows::single(2), Style::extended().get_frame())),
+        .with(Highlight::border(Rows::single(0), Border::inherit(StyleBuilder::extended())))
+        .with(Highlight::border(Rows::single(2), Border::inherit(StyleBuilder::extended()))),
     "╔═════════════════════════╗"
     "║ N   column 0   column 1 ║"
     "╚═════════════════════════╝"
@@ -563,7 +563,7 @@ test_table!(
 
 test_table!(
     single_column_off_horizontal_test,
-    Matrix::table(3, 0).with(Style::ascii().remove_horizontal().remove_vertical()),
+    Matrix::table(3, 0).with(StyleBuilder::ascii().remove_horizontal().remove_vertical()),
     "+---+"
     "| N |"
     "| 0 |"
@@ -655,16 +655,15 @@ test_table!(
     Matrix::new(3, 3)
         .insert((1, 1), "a longer string")
         .with({
-            let mut style: RawStyle = Style::modern().into();
-            style
-                .set_bottom(Some('a'))
-                .set_left(Some('b'))
-                .set_right(None)
-                .set_top(None)
-                .set_intersection(Some('x'))
-                .set_intersection_top(None)
-                .set_corner_top_left(None)
-                .set_corner_top_right(None);
+            let mut style: Style = Style::modern();
+            style.set_bottom(Some('a'));
+            style.set_left(Some('b'));
+            style.set_right(None);
+            style.set_top(None);
+            style.set_intersection(Some('x'));
+            style.set_intersection_top(None);
+            style.set_corner_top_left(None);
+            style.set_corner_top_right(None);
             style
         }),
     "b N │    column 0     │ column 1 │ column 2  "
@@ -682,7 +681,7 @@ test_table!(
     Matrix::new(3, 3)
         .insert((1, 1), "a longer string")
         .with({
-            let mut style: RawStyle = Style::modern().into();
+            let mut style: Style = Style::modern();
             style.set_bottom(None);
             style
         }),
@@ -702,7 +701,7 @@ test_table!(
     Matrix::new(3, 3)
         .insert((1, 1), "a longer string")
         .with({
-            let mut style: RawStyle = Style::modern().into();
+            let mut style: Style = Style::modern();
             style.set_bottom(None);
             style
         })
@@ -759,7 +758,7 @@ fn custom_style_test() {
     // Single
 
     test_style!(
-        Style::empty().top('-'),
+        StyleBuilder::empty().top('-'),
         static_table!(
             "---------------------------------"
             " N  column 0  column 1  column 2 "
@@ -769,7 +768,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().bottom('-'),
+        StyleBuilder::empty().bottom('-'),
         static_table!(
             " N  column 0  column 1  column 2 "
             " 0    0-0       0-1       0-2    "
@@ -779,7 +778,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().left('-'),
+        StyleBuilder::empty().left('-'),
         static_table!(
             "- N  column 0  column 1  column 2 "
             "- 0    0-0       0-1       0-2    "
@@ -788,7 +787,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().right('-'),
+        StyleBuilder::empty().right('-'),
         static_table!(
             " N  column 0  column 1  column 2 -"
             " 0    0-0       0-1       0-2    -"
@@ -797,7 +796,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().horizontal('-'),
+        StyleBuilder::empty().horizontal('-'),
         static_table!(
             " N  column 0  column 1  column 2 "
             "---------------------------------"
@@ -809,7 +808,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().horizontals([(1, HorizontalLine::new('-'))]),
+        StyleBuilder::empty().horizontals([(1, HorizontalLine::new('-'))]),
         static_table!(
             " N  column 0  column 1  column 2 "
             "---------------------------------"
@@ -819,7 +818,7 @@ fn custom_style_test() {
         ),
     );
     test_style!(
-        Style::empty().vertical('-'),
+        StyleBuilder::empty().vertical('-'),
         static_table!(
             " N - column 0 - column 1 - column 2 "
             " 0 -   0-0    -   0-1    -   0-2    "
@@ -831,7 +830,7 @@ fn custom_style_test() {
     // Combinations
 
     test_style!(
-        Style::empty().top('-').bottom('+'),
+        StyleBuilder::empty().top('-').bottom('+'),
         static_table!(
             "---------------------------------"
             " N  column 0  column 1  column 2 "
@@ -842,7 +841,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().top('-').left('+'),
+        StyleBuilder::empty().top('-').left('+'),
         static_table!(
             "+---------------------------------"
             "+ N  column 0  column 1  column 2 "
@@ -852,7 +851,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().top('-').right('+'),
+        StyleBuilder::empty().top('-').right('+'),
         static_table!(
             "---------------------------------+"
             " N  column 0  column 1  column 2 +"
@@ -862,7 +861,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().top('-').horizontal('+'),
+        StyleBuilder::empty().top('-').horizontal('+'),
         static_table!(
             "---------------------------------"
             " N  column 0  column 1  column 2 "
@@ -875,7 +874,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().top('-').vertical('+'),
+        StyleBuilder::empty().top('-').vertical('+'),
         static_table!(
             "---+----------+----------+----------"
             " N + column 0 + column 1 + column 2 "
@@ -885,7 +884,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .top('-')
             .horizontals([(1, HorizontalLine::new('+'))]),
         static_table!(
@@ -899,7 +898,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty().bottom('-').top('+'),
+        StyleBuilder::empty().bottom('-').top('+'),
         static_table!(
             "+++++++++++++++++++++++++++++++++"
             " N  column 0  column 1  column 2 "
@@ -910,7 +909,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().bottom('-').left('+'),
+        StyleBuilder::empty().bottom('-').left('+'),
         static_table!(
             "+ N  column 0  column 1  column 2 "
             "+ 0    0-0       0-1       0-2    "
@@ -920,7 +919,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().bottom('-').right('+'),
+        StyleBuilder::empty().bottom('-').right('+'),
         static_table!(
             " N  column 0  column 1  column 2 +"
             " 0    0-0       0-1       0-2    +"
@@ -930,7 +929,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().bottom('-').vertical('+'),
+        StyleBuilder::empty().bottom('-').vertical('+'),
         static_table!(
             " N + column 0 + column 1 + column 2 "
             " 0 +   0-0    +   0-1    +   0-2    "
@@ -940,7 +939,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().bottom('-').horizontal('+'),
+        StyleBuilder::empty().bottom('-').horizontal('+'),
         static_table!(
             " N  column 0  column 1  column 2 "
             "+++++++++++++++++++++++++++++++++"
@@ -953,7 +952,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .bottom('-')
             .horizontals([(1, HorizontalLine::new('+'))]),
         static_table!(
@@ -967,7 +966,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty().left('-').top('+'),
+        StyleBuilder::empty().left('-').top('+'),
         static_table!(
             "++++++++++++++++++++++++++++++++++"
             "- N  column 0  column 1  column 2 "
@@ -977,7 +976,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().left('-').bottom('+'),
+        StyleBuilder::empty().left('-').bottom('+'),
         static_table!(
             "- N  column 0  column 1  column 2 "
             "- 0    0-0       0-1       0-2    "
@@ -987,7 +986,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().left('-').right('+'),
+        StyleBuilder::empty().left('-').right('+'),
         static_table!(
             "- N  column 0  column 1  column 2 +"
             "- 0    0-0       0-1       0-2    +"
@@ -996,7 +995,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().left('-').vertical('+'),
+        StyleBuilder::empty().left('-').vertical('+'),
         static_table!(
             "- N + column 0 + column 1 + column 2 "
             "- 0 +   0-0    +   0-1    +   0-2    "
@@ -1005,7 +1004,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().left('-').horizontal('+'),
+        StyleBuilder::empty().left('-').horizontal('+'),
         static_table!(
             "- N  column 0  column 1  column 2 "
             "++++++++++++++++++++++++++++++++++"
@@ -1017,7 +1016,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .left('-')
             .horizontals([(1, HorizontalLine::new('+').left(' '))]),
         static_table!(
@@ -1030,7 +1029,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty().right('-').top('+'),
+        StyleBuilder::empty().right('-').top('+'),
         static_table!(
             "++++++++++++++++++++++++++++++++++"
             " N  column 0  column 1  column 2 -"
@@ -1040,7 +1039,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().right('-').bottom('+'),
+        StyleBuilder::empty().right('-').bottom('+'),
         static_table!(
             " N  column 0  column 1  column 2 -"
             " 0    0-0       0-1       0-2    -"
@@ -1050,7 +1049,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().right('-').left('+'),
+        StyleBuilder::empty().right('-').left('+'),
         static_table!(
             "+ N  column 0  column 1  column 2 -"
             "+ 0    0-0       0-1       0-2    -"
@@ -1059,7 +1058,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().right('-').vertical('+'),
+        StyleBuilder::empty().right('-').vertical('+'),
         static_table!(
             " N + column 0 + column 1 + column 2 -"
             " 0 +   0-0    +   0-1    +   0-2    -"
@@ -1068,7 +1067,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().right('-').horizontal('+'),
+        StyleBuilder::empty().right('-').horizontal('+'),
         static_table!(
             " N  column 0  column 1  column 2 -"
             "++++++++++++++++++++++++++++++++++"
@@ -1080,7 +1079,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .right('-')
             .horizontals([(1, HorizontalLine::new('+').right(' '))]),
         static_table!(
@@ -1093,7 +1092,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty().vertical('-').top('+'),
+        StyleBuilder::empty().vertical('-').top('+'),
         static_table!(
             "++++++++++++++++++++++++++++++++++++"
             " N - column 0 - column 1 - column 2 "
@@ -1103,7 +1102,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().vertical('-').bottom('+'),
+        StyleBuilder::empty().vertical('-').bottom('+'),
         static_table!(
             " N - column 0 - column 1 - column 2 "
             " 0 -   0-0    -   0-1    -   0-2    "
@@ -1113,7 +1112,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().vertical('-').left('+'),
+        StyleBuilder::empty().vertical('-').left('+'),
         static_table!(
             "+ N - column 0 - column 1 - column 2 "
             "+ 0 -   0-0    -   0-1    -   0-2    "
@@ -1122,7 +1121,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().vertical('-').right('+'),
+        StyleBuilder::empty().vertical('-').right('+'),
         static_table!(
             " N - column 0 - column 1 - column 2 +"
             " 0 -   0-0    -   0-1    -   0-2    +"
@@ -1131,7 +1130,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().vertical('-').horizontal('+'),
+        StyleBuilder::empty().vertical('-').horizontal('+'),
         static_table!(
             " N - column 0 - column 1 - column 2 "
             "++++++++++++++++++++++++++++++++++++"
@@ -1143,7 +1142,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .vertical('-')
             .horizontals([(1, HorizontalLine::new('+').intersection(' '))]),
         static_table!(
@@ -1156,7 +1155,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty().horizontal('-').top('+'),
+        StyleBuilder::empty().horizontal('-').top('+'),
         static_table!(
             "+++++++++++++++++++++++++++++++++"
             " N  column 0  column 1  column 2 "
@@ -1169,7 +1168,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().horizontal('-').bottom('+'),
+        StyleBuilder::empty().horizontal('-').bottom('+'),
         static_table!(
             " N  column 0  column 1  column 2 "
             "---------------------------------"
@@ -1182,7 +1181,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().horizontal('-').left('+'),
+        StyleBuilder::empty().horizontal('-').left('+'),
         static_table!(
             "+ N  column 0  column 1  column 2 "
             "+---------------------------------"
@@ -1194,7 +1193,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().horizontal('-').right('+'),
+        StyleBuilder::empty().horizontal('-').right('+'),
         static_table!(
             " N  column 0  column 1  column 2 +"
             "---------------------------------+"
@@ -1206,7 +1205,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty().horizontal('-').vertical('+'),
+        StyleBuilder::empty().horizontal('-').vertical('+'),
         static_table!(
             " N + column 0 + column 1 + column 2 "
             "---+----------+----------+----------"
@@ -1218,7 +1217,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontal('-')
             .horizontals([(1, HorizontalLine::new('+'))]),
         static_table!(
@@ -1233,7 +1232,7 @@ fn custom_style_test() {
     );
 
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .top('+')
             .horizontals([(1, HorizontalLine::new('-'))]),
         static_table!(
@@ -1246,7 +1245,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontals([(1, HorizontalLine::new('-'))])
             .bottom('+'),
         static_table!(
@@ -1259,7 +1258,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontals([(1, HorizontalLine::new('-'))])
             .left('+'),
         static_table!(
@@ -1271,7 +1270,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontals([(1, HorizontalLine::new('-'))])
             .right('+'),
         static_table!(
@@ -1283,7 +1282,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontals([(1, HorizontalLine::new('-'))])
             .vertical('+'),
         static_table!(
@@ -1295,7 +1294,7 @@ fn custom_style_test() {
         )
     );
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .horizontals([(1, HorizontalLine::new('-'))])
             .horizontal('+'),
         static_table!(
@@ -1312,7 +1311,7 @@ fn custom_style_test() {
     // Full
 
     test_style!(
-        Style::empty()
+        StyleBuilder::empty()
             .top('-')
             .bottom('+')
             .left('|')
@@ -1333,7 +1332,7 @@ fn custom_style_test() {
         ),
     );
 
-    let full_style = Style::empty()
+    let full_style = StyleBuilder::empty()
         .top('-')
         .bottom('+')
         .left('|')
@@ -1349,7 +1348,7 @@ fn custom_style_test() {
         .corner_bottom_left('?')
         .corner_top_right('.')
         .corner_bottom_right('%')
-        .horizontals([(1, HorizontalLine::full(',', ',', ',', '#'))]);
+        .horizontals([(1, HorizontalLine::full(',', '#', ',', ','))]);
 
     test_style!(
         full_style.clone(),
@@ -1477,17 +1476,23 @@ fn custom_style_test() {
         " 1    1-0       1-1       1-2    "
         " 2    2-0       2-1       2-2    "
     );
-    test_style!(Style::empty().top('-').remove_top(), empty_table);
-    test_style!(Style::empty().bottom('-').remove_bottom(), empty_table);
-    test_style!(Style::empty().right('-').remove_right(), empty_table);
-    test_style!(Style::empty().left('-').remove_left(), empty_table);
+    test_style!(StyleBuilder::empty().top('-').remove_top(), empty_table);
+    test_style!(
+        StyleBuilder::empty().bottom('-').remove_bottom(),
+        empty_table
+    );
+    test_style!(StyleBuilder::empty().right('-').remove_right(), empty_table);
+    test_style!(StyleBuilder::empty().left('-').remove_left(), empty_table);
+    test_style!(
+        StyleBuilder::empty().horizontal('-').remove_horizontal(),
+        empty_table
+    );
     test_style!(
-        Style::empty().horizontal('-').remove_horizontal(),
+        StyleBuilder::empty().vertical('-').remove_vertical(),
         empty_table
     );
-    test_style!(Style::empty().vertical('-').remove_vertical(), empty_table);
     test_style!(
-        Style::empty().horizontals([(1, HorizontalLine::new('-'))]),
+        StyleBuilder::empty().horizontals([(1, HorizontalLine::new('-'))]),
         static_table!(
             " N  column 0  column 1  column 2 "
             "---------------------------------"
@@ -2140,21 +2145,19 @@ fn border_colored_test() {
 #[cfg(feature = "color")]
 #[test]
 fn style_with_color_test() {
-    let mut style: RawStyle = Style::ascii().into();
-    style
-        .set_left(Some('['))
-        .set_right(Some(']'))
-        .set_top(Some('-'))
-        .set_bottom(Some('-'))
-        .set_vertical(Some('|'))
-        .set_intersection(Some('+'));
-    style
-        .set_color_left(Color::FG_RED)
-        .set_color_right(Color::FG_RED)
-        .set_color_top(Color::FG_BLUE)
-        .set_color_bottom(Color::FG_BLUE)
-        .set_color_vertical(Color::FG_YELLOW)
-        .set_color_intersection(Color::try_from(' '.purple().to_string()).unwrap());
+    let mut style = Style::ascii();
+    style.set_left(Some('['));
+    style.set_right(Some(']'));
+    style.set_top(Some('-'));
+    style.set_bottom(Some('-'));
+    style.set_vertical(Some('|'));
+    style.set_intersection(Some('+'));
+    style.set_color_left(Color::FG_RED);
+    style.set_color_right(Color::FG_RED);
+    style.set_color_top(Color::FG_BLUE);
+    style.set_color_bottom(Color::FG_BLUE);
+    style.set_color_vertical(Color::FG_YELLOW);
+    style.set_color_intersection(Color::try_from(' '.purple().to_string()).unwrap());
 
     let table = Matrix::new(3, 3).with(style).to_string();
 
@@ -2178,7 +2181,7 @@ fn style_with_color_test() {
 
 test_table!(
     empty_line_clears_lines,
-    Matrix::new(3, 3).with(Style::rounded().remove_horizontals()),
+    Matrix::new(3, 3).with(StyleBuilder::rounded().remove_horizontals()),
     "╭───┬──────────┬──────────┬──────────╮"
     "│ N │ column 0 │ column 1 │ column 2 │"
     "│ 0 │   0-0    │   0-1    │   0-2    │"
@@ -2189,7 +2192,7 @@ test_table!(
 
 test_table!(
     empty_line_clears_lines_1,
-    Matrix::new(3, 3).with(Style::rounded().remove_horizontals()),
+    Matrix::new(3, 3).with(StyleBuilder::rounded().remove_horizontals()),
     "╭───┬──────────┬──────────┬──────────╮"
     "│ N │ column 0 │ column 1 │ column 2 │"
     "│ 0 │   0-0    │   0-1    │   0-2    │"
@@ -2219,7 +2222,7 @@ test_table!(
 test_table!(
     verticals_0,
     Matrix::new(3, 3)
-        .with(Style::rounded().verticals([(0, VerticalLine::filled('+').remove_intersection()), (4, VerticalLine::filled('+').remove_intersection())])),
+        .with(StyleBuilder::rounded().verticals([(0, VerticalLine::filled('+').remove_intersection()), (4, VerticalLine::filled('+').remove_intersection())])),
     "+───┬──────────┬──────────┬──────────+"
     "+ N │ column 0 │ column 1 │ column 2 +"
     "├───┼──────────┼──────────┼──────────┤"
@@ -2232,9 +2235,9 @@ test_table!(
 test_table!(
     verticals_1,
     {
-        let verticals = (1..4).map(|i| (i, VerticalLine::filled('+').into_inner())).collect::<HashMap<_, _>>();
-        let mut style = RawStyle::from(Style::rounded());
-        style.set_verticals(verticals);
+        let verticals = (1..4).map(|i| (i, VerticalLine::filled('+').into())).collect();
+        let mut style = Style::rounded();
+        style.set_lines_vertical(verticals);
 
         Matrix::new(3, 3).with(style)
     },
@@ -2249,7 +2252,7 @@ test_table!(
 
 test_table!(
     verticals_2,
-    Matrix::new(3, 3).with(Style::rounded().verticals([(1, VerticalLine::filled('+').remove_intersection())])),
+    Matrix::new(3, 3).with(StyleBuilder::rounded().verticals([(1, VerticalLine::filled('+').remove_intersection())])),
     "╭───+──────────┬──────────┬──────────╮"
     "│ N + column 0 │ column 1 │ column 2 │"
     "├───┼──────────┼──────────┼──────────┤"
@@ -2261,7 +2264,7 @@ test_table!(
 
 test_table!(
     verticals_3,
-    Matrix::new(3, 3).with(Style::ascii().verticals([(1, VerticalLine::filled('*'))])),
+    Matrix::new(3, 3).with(StyleBuilder::ascii().verticals([(1, VerticalLine::filled('*'))])),
     "+---*----------+----------+----------+"
     "| N * column 0 | column 1 | column 2 |"
     "+---*----------+----------+----------+"
@@ -2276,9 +2279,9 @@ test_table!(
 test_table!(
     verticals_4,
     {
-        let mut style = RawStyle::from(Style::ascii());
-        let verticals = (0..10).map(|i| (i, VerticalLine::full('*', 'c', '2', 'x').into_inner())).collect();
-        style.set_verticals(verticals);
+        let mut style = Style::ascii();
+        let verticals = (0..10).map(|i| (i, VerticalLine::full('*', 'x', 'c', '2').into())).collect();
+        style.set_lines_vertical(verticals);
 
         Matrix::new(3, 3).with(style)
     },
@@ -2298,9 +2301,9 @@ test_table!(
     {
         let m = Matrix::new(3, 3);
 
-        let mut style = RawStyle::from(Style::ascii());
-        style.insert_horizontal(1, Line::full('8', '8', '8', '8'));
-        style.insert_vertical(1, Line::full('*', 'x', 'c', '2'));
+        let mut style = Style::ascii();
+        style.insert_line_horizontal(1, HorizontalLine::full('8', '8', '8', '8').into());
+        style.insert_line_vertical(1, VerticalLine::full('*', 'x', 'c', '2').into());
 
         m.with(style)
     },
@@ -2323,7 +2326,7 @@ test_table!(
 test_table!(
     vertical_line_1,
     Matrix::new(3, 3)
-        .with(Style::empty().verticals([(1, VerticalLine::new('*'))])),
+        .with(StyleBuilder::empty().verticals([(1, VerticalLine::new('*'))])),
     " N * column 0  column 1  column 2 "
     " 0 *   0-0       0-1       0-2    "
     " 1 *   1-0       1-1       1-2    "
@@ -2610,14 +2613,14 @@ test_table!(
 
 test_table!(
     table_style_no_bottom_no_new_line,
-    Matrix::table(0, 0).with(Style::markdown().remove_horizontals()),
+    Matrix::table(0, 0).with(StyleBuilder::markdown().remove_horizontals()),
     "| N |"
 );
 
 test_table!(
     style_const_modification,
     {
-        const STYLE: Style<On, On, On, On, On, On, 1, 0> = Style::ascii()
+        const STYLE: StyleBuilder<On, On, On, On, On, On, 1, 0> = StyleBuilder::ascii()
             .bottom('x')
             .horizontals([(1, HorizontalLine::filled('.'))]);
         Matrix::new(3, 3).with(STYLE)
@@ -2636,7 +2639,7 @@ test_table!(
 test_table!(
     style_static_modification,
     {
-        static STYLE: Style<On, On, On, On, On, On, 1, 1> = Style::ascii()
+        static STYLE: StyleBuilder<On, On, On, On, On, On, 1, 1> = StyleBuilder::ascii()
             .bottom('x')
             .horizontals([(1, HorizontalLine::filled('.'))])
             .verticals([(1, VerticalLine::filled('|'))]);
diff --git a/tabled/tests/settings/width_test.rs b/tabled/tests/settings/width_test.rs
index 90d8d86..b7688f3 100644
--- a/tabled/tests/settings/width_test.rs
+++ b/tabled/tests/settings/width_test.rs
@@ -15,7 +15,10 @@ use crate::matrix::Matrix;
 use testing_table::{is_lines_equal, static_table, test_table};
 
 #[cfg(feature = "color")]
-use ::{ansi_str::AnsiStr, owo_colors::OwoColorize};
+use ::{
+    ansi_str::AnsiStr, owo_colors::OwoColorize, tabled::settings::style::HorizontalLine,
+    tabled::settings::style::StyleBuilder,
+};
 
 #[cfg(all(feature = "derive", feature = "color"))]
 use ::owo_colors::AnsiColors;
@@ -445,9 +448,9 @@ fn max_width_keep_words_1() {
         ["0", "1", "..."],
     ])
     .with(
-        Style::modern()
+        StyleBuilder::modern()
             .remove_horizontal()
-            .horizontals([(1, Style::modern().get_horizontal_line())]),
+            .horizontals([(1, HorizontalLine::inherit(StyleBuilder::modern()))]),
     )
     .with(Width::wrap(21).keep_words().priority::<PriorityMax>())
     .with(Alignment::center())