diff --git a/src/lib.rs b/src/lib.rs
index cbf106b..ca3adbb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -399,7 +399,7 @@ pub use {
     mat::Mat,
     read::{
         error::ReadError,
-        locale,
+        fmt,
         read_from::{ReadFrom, ReadFromError},
         read_into::ReadInto,
         read_one_from::{ReadOneFrom, ReadOneFromError},
diff --git a/src/read/fmt.rs b/src/read/fmt.rs
new file mode 100644
index 0000000..7ca752b
--- /dev/null
+++ b/src/read/fmt.rs
@@ -0,0 +1,137 @@
+//! [Format] trait for input format and built-in formats.
+
+use crate::{
+    stream::{COMMA, CR, HT, LF, SP},
+    utf8char::FixedUtf8Char,
+};
+
+/// Trait for input format.
+pub trait Format<Char = char> {
+    /// Get the list of whitespace characters.
+    fn skipped_chars(&self) -> &[Char];
+}
+
+impl<L: Format<Char> + ?Sized, Char> Format<Char> for &L {
+    #[inline]
+    fn skipped_chars(&self) -> &[Char] {
+        <L as Format<Char>>::skipped_chars(self)
+    }
+}
+
+/// Default Format.
+///
+/// Whitespace characters here are `' '`, `'\t'`, `'\n'`, and `'\r'`.
+pub struct Default;
+
+const WHITE_SPACES: [FixedUtf8Char; 4] = [SP, HT, LF, CR];
+
+impl Format<FixedUtf8Char> for Default {
+    #[inline]
+    fn skipped_chars(&self) -> &[FixedUtf8Char] {
+        &WHITE_SPACES
+    }
+}
+
+impl Format<char> for Default {
+    #[inline]
+    fn skipped_chars(&self) -> &[char] {
+        &[' ', '\t', '\n', '\r']
+    }
+}
+
+/// Format for CSV.
+///
+/// Whitespace characters here are `' '`, `'\t'`, `','`, `'\n'`, and `'\r'`.
+pub struct CSV;
+
+const CSV_SEP: [FixedUtf8Char; 5] = [SP, HT, COMMA, LF, CR];
+
+impl Format<FixedUtf8Char> for CSV {
+    #[inline]
+    fn skipped_chars(&self) -> &[FixedUtf8Char] {
+        &CSV_SEP
+    }
+}
+
+impl Format<char> for CSV {
+    #[inline]
+    fn skipped_chars(&self) -> &[char] {
+        &[' ', '\t', ',', '\n', '\r']
+    }
+}
+
+/// Special format that skip the given characters.
+pub struct Skip<Char = char>(Vec<Char>);
+
+impl<Char: From<C> + Ord, C> FromIterator<C> for Skip<Char> {
+    #[inline]
+    fn from_iter<T: IntoIterator<Item = C>>(iter: T) -> Self {
+        let mut v: Vec<_> = iter.into_iter().map(From::from).collect();
+        v.sort();
+        v.dedup();
+        Self(v)
+    }
+}
+
+impl Format<FixedUtf8Char> for Skip<FixedUtf8Char> {
+    #[inline]
+    fn skipped_chars(&self) -> &[FixedUtf8Char] {
+        &self.0
+    }
+}
+
+impl Format<char> for Skip<char> {
+    #[inline]
+    fn skipped_chars(&self) -> &[char] {
+        &self.0
+    }
+}
+
+/// Create a [Format] instance that skip the given characters.
+#[inline]
+pub fn skip<Char: Ord, T: IntoIterator<Item = Char>>(iter: T) -> Skip<Char> {
+    iter.into_iter().collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Default;
+    use crate::{
+        fmt::{Format, Skip, CSV, WHITE_SPACES},
+        utf8char::FixedUtf8Char,
+    };
+
+    #[test]
+    fn equivalence() {
+        assert_eq!(
+            <Default as Format<char>>::skipped_chars(&Default),
+            <Default as Format<FixedUtf8Char>>::skipped_chars(&Default),
+        );
+        assert_eq!(
+            <&Default as Format<char>>::skipped_chars(&&Default),
+            <&Default as Format<FixedUtf8Char>>::skipped_chars(&&Default),
+        );
+        assert_eq!(
+            <CSV as Format<char>>::skipped_chars(&CSV),
+            <CSV as Format<FixedUtf8Char>>::skipped_chars(&CSV),
+        );
+        assert_eq!(
+            <&CSV as Format<char>>::skipped_chars(&&CSV),
+            <&CSV as Format<FixedUtf8Char>>::skipped_chars(&&CSV),
+        );
+
+        let seps = [' ', '\t', '\n', '\r'];
+        assert_eq!(
+            <Skip<char> as Format<char>>::skipped_chars(&FromIterator::from_iter(seps)),
+            <Skip<FixedUtf8Char> as Format<FixedUtf8Char>>::skipped_chars(
+                &FromIterator::from_iter(seps)
+            ),
+        );
+        assert_eq!(
+            <Skip<char> as Format<char>>::skipped_chars(&FromIterator::from_iter(WHITE_SPACES)),
+            <Skip<FixedUtf8Char> as Format<FixedUtf8Char>>::skipped_chars(
+                &FromIterator::from_iter(WHITE_SPACES)
+            ),
+        );
+    }
+}
diff --git a/src/read/impls.rs b/src/read/impls.rs
index caa26e1..88432e6 100644
--- a/src/read/impls.rs
+++ b/src/read/impls.rs
@@ -3,7 +3,7 @@ use crate::{
 };
 use std::{ffi::OsString, net::*, num::*, path::PathBuf};
 
-use super::locale;
+use super::fmt;
 
 // Implement `Parse` for all types that implement FromStr.
 impl_read_one_from_for_from_str!(
@@ -45,10 +45,10 @@ impl ReadOneFrom for char {
     }
 
     #[inline]
-    fn try_read_one_from<L: locale::Locale, S: BufReadExt>(
+    fn try_read_one_from<F: fmt::Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<char, ReadOneFromError<Self>> {
-        <Self as ReadOneFrom>::try_read_in_char_from(stream, locale)
+        <Self as ReadOneFrom>::try_read_in_char_from(stream, format)
     }
 }
diff --git a/src/read/iter.rs b/src/read/iter.rs
index bcbb404..a5e6d10 100644
--- a/src/read/iter.rs
+++ b/src/read/iter.rs
@@ -1,41 +1,38 @@
 use super::read_one_from::ReadOneFromError;
 use crate::{
-    locale::Locale,
+    fmt::Format,
     stream::{error::StreamError, line_buf::LineBuf},
     BufReadExt, ReadError, ReadOneFrom,
 };
 use std::marker::PhantomData;
 
 /// Iterator for all elements.
-pub(super) struct ReadAll<'l, 's, L: Locale, S: ?Sized, T: ReadOneFrom> {
-    locale: &'l L,
+pub(super) struct ReadAll<'f, 's, F: Format, S: ?Sized, T: ReadOneFrom> {
+    format: &'f F,
     stream: &'s mut S,
     phantom: PhantomData<T>,
 }
 
-impl<'l, 's, L: Locale, S: ?Sized, T: ReadOneFrom> ReadAll<'l, 's, L, S, T> {
+impl<'f, 's, F: Format, S: ?Sized, T: ReadOneFrom> ReadAll<'f, 's, F, S, T> {
     #[inline]
-    pub(crate) fn new(stream: &'s mut S, locale: &'l L) -> Self {
+    pub(crate) fn new(stream: &'s mut S, format: &'f F) -> Self {
         let phantom = PhantomData;
         Self {
-            locale,
+            format,
             stream,
             phantom,
         }
     }
 }
 
-impl<'l, 's, L: Locale, S: BufReadExt + ?Sized, T: ReadOneFrom> Iterator
-    for ReadAll<'l, 's, L, S, T>
+impl<'l, 's, F: Format, S: BufReadExt + ?Sized, T: ReadOneFrom> Iterator
+    for ReadAll<'l, 's, F, S, T>
 {
     type Item = Result<T, ReadOneFromError<T>>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match self
-            .stream
-            .try_get_string_some(self.locale.whitespace_chars())
-        {
+        match self.stream.try_get_string_some(self.format.skipped_chars()) {
             Ok(s) => Some(T::parse(s)),
             Err(StreamError::Eof | StreamError::Eol) => None,
             Err(e) => Some(Err(e.into())),
@@ -44,31 +41,31 @@ impl<'l, 's, L: Locale, S: BufReadExt + ?Sized, T: ReadOneFrom> Iterator
 }
 
 /// Iterator for all elements in a string.
-pub(super) struct ReadAllIn<'l, 's, L: Locale, T: ReadOneFrom> {
-    locale: &'l L,
+pub(super) struct ReadAllIn<'f, 's, F: Format, T: ReadOneFrom> {
+    format: &'f F,
     stream: LineBuf<'s>,
     phantom: PhantomData<T>,
 }
 
-impl<'l, 's, L: Locale, T: ReadOneFrom> ReadAllIn<'l, 's, L, T> {
+impl<'l, 's, L: Format, T: ReadOneFrom> ReadAllIn<'l, 's, L, T> {
     #[inline]
-    pub(crate) fn new(buffer: &'s str, locale: &'l L) -> Self {
+    pub(crate) fn new(buffer: &'s str, format: &'l L) -> Self {
         let stream = LineBuf::new(buffer);
         let phantom = PhantomData;
         Self {
-            locale,
+            format,
             stream,
             phantom,
         }
     }
 }
 
-impl<'l, 's, L: Locale, T: ReadOneFrom> Iterator for ReadAllIn<'l, 's, L, T> {
+impl<'l, 's, L: Format, T: ReadOneFrom> Iterator for ReadAllIn<'l, 's, L, T> {
     type Item = Result<T, ReadOneFromError<T>>;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match T::try_read_one_from(&mut self.stream, self.locale) {
+        match T::try_read_one_from(&mut self.stream, self.format) {
             Ok(t) => Some(Ok(t)),
             Err(ReadError::EOF | ReadError::EOL) => None,
             Err(e) => Some(Err(e)),
@@ -80,7 +77,7 @@ impl<'l, 's, L: Locale, T: ReadOneFrom> Iterator for ReadAllIn<'l, 's, L, T> {
 mod tests {
     use super::ReadAll;
     use crate::{
-        locale::{Locale, ASCII},
+        fmt::{Default, Format},
         stream::line_buf::LineBuf,
         unwrap, BufReadExt, InputStream, ReadInto,
     };
@@ -90,7 +87,7 @@ mod tests {
     fn line_buf_strings() {
         let s = "Hello, world!";
         let mut buf = LineBuf::new(s);
-        let iter = ReadAll::new(&mut buf, &ASCII);
+        let iter = ReadAll::new(&mut buf, &Default);
         let res: Result<Vec<String>, _> = iter.collect();
         let res = unwrap!(res);
         assert_eq!(res, vec!["Hello,", "world!"]);
@@ -100,7 +97,7 @@ mod tests {
     fn input_stream_strings() {
         let s = "Hello, world!";
         let mut buf = InputStream::new(Cursor::new(s));
-        let iter = ReadAll::new(&mut buf, &ASCII);
+        let iter = ReadAll::new(&mut buf, &Default);
         let res: Result<Vec<String>, _> = iter.collect();
         let res = unwrap!(res);
         assert_eq!(res, vec!["Hello,", "world!"]);
@@ -111,7 +108,7 @@ mod tests {
     fn line_buf_string() {
         let s = "\n";
         let mut buf = LineBuf::new(s);
-        let _: &str = unwrap!(buf.try_get_string_some(ASCII.whitespace_chars()));
+        let _: &str = unwrap!(buf.try_get_string_some(Default.skipped_chars()));
     }
 
     #[test]
@@ -119,7 +116,7 @@ mod tests {
     fn input_stream_string() {
         let s = "\n";
         let mut buf = InputStream::new(Cursor::new(s));
-        let _: &str = unwrap!(buf.try_get_string_some(ASCII.whitespace_chars()));
+        let _: &str = unwrap!(buf.try_get_string_some(Default.skipped_chars()));
     }
 
     #[test]
diff --git a/src/read/locale.rs b/src/read/locale.rs
deleted file mode 100644
index f73b4e7..0000000
--- a/src/read/locale.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-//! Locale trait and default locale.
-
-use crate::{
-    stream::{COMMA, CR, HT, LF, SP},
-    utf8char::FixedUtf8Char,
-};
-
-/// Locale trait.
-pub trait Locale<Char = char> {
-    /// Get the list of whitespace characters.
-    fn whitespace_chars(&self) -> &[Char];
-}
-
-impl<L: Locale<Char> + ?Sized, Char> Locale<Char> for &L {
-    #[inline]
-    fn whitespace_chars(&self) -> &[Char] {
-        <L as Locale<Char>>::whitespace_chars(self)
-    }
-}
-
-/// Default locale.
-///
-/// Whitespace characters here are `' '`, `'\t'`, `'\n'`, and `'\r'`.
-pub struct ASCII;
-
-const WHITE_SPACES: [FixedUtf8Char; 4] = [SP, HT, LF, CR];
-
-impl Locale<FixedUtf8Char> for ASCII {
-    #[inline]
-    fn whitespace_chars(&self) -> &[FixedUtf8Char] {
-        &WHITE_SPACES
-    }
-}
-
-impl Locale<char> for ASCII {
-    #[inline]
-    fn whitespace_chars(&self) -> &[char] {
-        &[' ', '\t', '\n', '\r']
-    }
-}
-
-/// Locale for CSV.
-///
-/// Whitespace characters here are `' '`, `'\t'`, `','`, `'\n'`, and `'\r'`.
-pub struct CSV;
-
-const CSV_SEP: [FixedUtf8Char; 5] = [SP, HT, COMMA, LF, CR];
-
-impl Locale<FixedUtf8Char> for CSV {
-    #[inline]
-    fn whitespace_chars(&self) -> &[FixedUtf8Char] {
-        &CSV_SEP
-    }
-}
-
-impl Locale<char> for CSV {
-    #[inline]
-    fn whitespace_chars(&self) -> &[char] {
-        &[' ', '\t', ',', '\n', '\r']
-    }
-}
-
-/// Specific locale for whitespace characters.
-pub struct WS<Char = char>(Vec<Char>);
-
-impl<Char: From<FixedUtf8Char> + Ord> FromIterator<FixedUtf8Char> for WS<Char> {
-    #[inline]
-    fn from_iter<T: IntoIterator<Item = FixedUtf8Char>>(iter: T) -> Self {
-        let mut v: Vec<_> = iter.into_iter().map(From::from).collect();
-        v.sort();
-        v.dedup();
-        Self(v)
-    }
-}
-
-impl<Char: From<char> + Ord> FromIterator<char> for WS<Char> {
-    #[inline]
-    fn from_iter<T: IntoIterator<Item = char>>(iter: T) -> Self {
-        let mut v: Vec<_> = iter.into_iter().map(From::from).collect();
-        v.sort();
-        v.dedup();
-        Self(v)
-    }
-}
-
-impl Locale<FixedUtf8Char> for WS<FixedUtf8Char> {
-    #[inline]
-    fn whitespace_chars(&self) -> &[FixedUtf8Char] {
-        &self.0
-    }
-}
-
-impl Locale<char> for WS<char> {
-    #[inline]
-    fn whitespace_chars(&self) -> &[char] {
-        &self.0
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ASCII;
-    use crate::{
-        locale::{Locale, CSV, WHITE_SPACES, WS},
-        utf8char::FixedUtf8Char,
-    };
-
-    #[test]
-    fn equivalence() {
-        assert_eq!(
-            <ASCII as Locale<char>>::whitespace_chars(&ASCII),
-            <ASCII as Locale<FixedUtf8Char>>::whitespace_chars(&ASCII),
-        );
-        assert_eq!(
-            <&ASCII as Locale<char>>::whitespace_chars(&&ASCII),
-            <&ASCII as Locale<FixedUtf8Char>>::whitespace_chars(&&ASCII),
-        );
-        assert_eq!(
-            <CSV as Locale<char>>::whitespace_chars(&CSV),
-            <CSV as Locale<FixedUtf8Char>>::whitespace_chars(&CSV),
-        );
-        assert_eq!(
-            <&CSV as Locale<char>>::whitespace_chars(&&CSV),
-            <&CSV as Locale<FixedUtf8Char>>::whitespace_chars(&&CSV),
-        );
-
-        let seps = [' ', '\t', '\n', '\r'];
-        assert_eq!(
-            <WS<char> as Locale<char>>::whitespace_chars(&FromIterator::from_iter(seps)),
-            <WS<FixedUtf8Char> as Locale<FixedUtf8Char>>::whitespace_chars(
-                &FromIterator::from_iter(seps)
-            ),
-        );
-        assert_eq!(
-            <WS<char> as Locale<char>>::whitespace_chars(&FromIterator::from_iter(WHITE_SPACES)),
-            <WS<FixedUtf8Char> as Locale<FixedUtf8Char>>::whitespace_chars(
-                &FromIterator::from_iter(WHITE_SPACES)
-            ),
-        );
-    }
-}
diff --git a/src/read/macros.rs b/src/read/macros.rs
index 3da4df1..db2e0af 100644
--- a/src/read/macros.rs
+++ b/src/read/macros.rs
@@ -3,7 +3,7 @@
 /// The intended grammar is:
 ///
 /// ```rust,ignore
-/// $($dims:expr),* $(,)? $(; src = $src:expr)? $(; loc = $loc:expr)?
+/// $($dims:expr),* $(,)? $(; src = $src:expr)? $(; fmt = $fmt:expr)?
 /// ```
 ///
 /// - `read!()` reads a single data item from input.
@@ -44,13 +44,13 @@
 #[doc = include_str!("../../examples/doc_macro_read.rs")]
 /// ```
 ///
-/// Also, you can specify the source (as long as it implements [BufReadExt](crate::BufReadExt)) and locale (as long as it implements [Locale]) for reading.
+/// Also, you can specify the source (as long as it implements [BufReadExt](crate::BufReadExt)) and format (as long as it implements [Format]) for reading.
 ///
 /// [BufReadExt]: crate::BufReadExt
-/// [Locale]: crate::locale::Locale
+/// [Format]: crate::fmt::Format
 ///
 /// ```rust
-/// use iof::{locale, read, InputStream, Mat};
+/// use iof::{fmt::CSV, read, InputStream, Mat};
 ///
 /// let a: usize = read!(; src = InputStream::new(b"42".as_slice()));
 /// assert_eq!(a, 42);
@@ -58,36 +58,52 @@
 /// let b: Vec<usize> = read!(3; src = InputStream::new(b"1 2 3".as_slice()));
 /// assert_eq!(b, [1, 2, 3]);
 ///
-/// let b: Vec<usize> = read!(3; src = InputStream::new(b"1, 2, 3".as_slice()); loc = locale::CSV);
+/// let b: Vec<usize> = read!(3; src = InputStream::new(b"1, 2, 3".as_slice()); fmt = CSV);
 /// assert_eq!(b, [1, 2, 3]);
 ///
-/// let s = b"1,2,3;4,5,6";
+/// let s = b"010\n101";
 ///
-/// let b: Mat<usize> = read!(2, 3; src = InputStream::new(s.as_slice()); loc = locale::WS::from_iter([' ', ',', ';']));
+/// let b: Mat<char> = read!(2, 3; src = InputStream::new(s.as_slice()); skip = [' ', ',', ';', '\n', '\r']);
+/// assert_eq!(b, [['0', '1', '0'], ['1', '0', '1']]);
+///
+/// let s = b"1,2,3;4,5,6\r\n";
+///
+/// let b: Mat<usize> = read!(2, 3; src = InputStream::new(s.as_slice()); skip = [' ', ',', ';', '\r', '\n']);
 /// assert_eq!(b, [[1, 2, 3], [4, 5, 6]]);
 ///
-/// let b: Mat<usize> = read!(2, 3; src = InputStream::new(s.as_slice()); loc = locale::WS::from_iter(" \t,;".chars()));
+/// let b: Mat<usize> = read!(2, 3; src = InputStream::new(s.as_slice()); skip = " \t,;\r\n".chars());
 /// assert_eq!(b, [[1, 2, 3], [4, 5, 6]]);
 /// ```
 #[macro_export]
 macro_rules! read {
-    (@ $(,)?; src = $src:expr; loc = $loc:expr) => {
-        $crate::unwrap!($crate::ReadFrom::try_read_from($src, $loc))
+    (@ $(,)?; src = $src:expr; fmt = $fmt:expr) => {
+        $crate::unwrap!($crate::ReadFrom::try_read_from($src, $fmt))
     };
-    (@ $dim0:expr $(, $dims:expr)* $(,)?; src = $src:expr; loc = $loc:expr) => {{
+    (@ $dim0:expr $(, $dims:expr)* $(,)?; src = $src:expr; fmt = $fmt:expr) => {{
         let range = 0usize..$dim0;
-        ::std::vec::Vec::<_>::from_iter(range.map(|_| $crate::read!(@ $($dims, )* ; src = $src ; loc = $loc)))
+        ::std::vec::Vec::<_>::from_iter(range.map(|_| $crate::read!(@ $($dims, )* ; src = $src ; fmt = $fmt)))
+    }};
+    ($(,)? $(; src = $src:expr)? $(; fmt = $fmt:expr)?) => {{
+        let src = $crate::argument_or_default!($(&mut $src)?, &mut *$crate::stdin());
+        let fmt = $crate::argument_or_default!($(&$fmt)?, &$crate::fmt::Default);
+        $crate::unwrap!($crate::ReadFrom::try_read_from(src, fmt))
+    }};
+    ($dim0:expr $(, $dims:expr)* $(,)? $(; src = $src:expr)? $(; fmt = $fmt:expr)?) => {{
+        let range = 0usize..$dim0;
+        let src = $crate::argument_or_default!($(&mut $src)?, &mut *$crate::stdin());
+        let fmt = $crate::argument_or_default!($(&$fmt)?, &$crate::fmt::Default);
+        ::std::vec::Vec::<_>::from_iter(range.map(|_| $crate::read!(@ $($dims, )*; src = src; fmt = fmt)))
     }};
-    ($(,)? $(; src = $src:expr)? $(; loc = $loc:expr)?) => {{
+    ($(,)? $(; src = $src:expr)? ; skip = $skip:expr) => {{
         let src = $crate::argument_or_default!($(&mut $src)?, &mut *$crate::stdin());
-        let loc = $crate::argument_or_default!($(&$loc)?, &$crate::locale::ASCII);
-        $crate::unwrap!($crate::ReadFrom::try_read_from(src, loc))
+        let fmt = &$crate::fmt::skip($skip);
+        $crate::unwrap!($crate::ReadFrom::try_read_from(src, fmt))
     }};
-    ($dim0:expr $(, $dims:expr)* $(,)? $(; src = $src:expr)? $(; loc = $loc:expr)?) => {{
+    ($dim0:expr $(, $dims:expr)* $(,)? $(; src = $src:expr)? ; skip = $skip:expr) => {{
         let range = 0usize..$dim0;
         let src = $crate::argument_or_default!($(&mut $src)?, &mut *$crate::stdin());
-        let loc = $crate::argument_or_default!($(&$loc)?, &$crate::locale::ASCII);
-        ::std::vec::Vec::<_>::from_iter(range.map(|_| $crate::read!(@ $($dims, )*; src = src; loc = loc)))
+        let fmt = &$crate::fmt::skip($skip);
+        ::std::vec::Vec::<_>::from_iter(range.map(|_| $crate::read!(@ $($dims, )*; src = src; fmt = fmt)))
     }};
 }
 
diff --git a/src/read/mod.rs b/src/read/mod.rs
index 4e40d00..65913ff 100644
--- a/src/read/mod.rs
+++ b/src/read/mod.rs
@@ -1,7 +1,7 @@
 pub(super) mod error;
+pub mod fmt;
 mod impls;
 mod iter;
-pub mod locale;
 mod macros;
 pub(super) mod read_from;
 pub(super) mod read_into;
diff --git a/src/read/read_from.rs b/src/read/read_from.rs
index dd3bc12..627c10e 100644
--- a/src/read/read_from.rs
+++ b/src/read/read_from.rs
@@ -1,4 +1,4 @@
-use super::{locale::Locale, read_one_from::ReadOneFrom};
+use super::{fmt::Format, read_one_from::ReadOneFrom};
 use crate::{array::array_try_from_fn, mat::Mat, BufReadExt, ReadError};
 
 /// The error type for [ReadFrom].
@@ -20,34 +20,34 @@ pub trait ReadFrom: Sized {
     type ParseError: std::error::Error;
 
     /// Read from `self` and parse into `Self`.
-    fn try_read_from<L: Locale, S: BufReadExt>(
+    fn try_read_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadFromError<Self>>;
     /// Read `n` elements from `self`, parse into `Self` and aggregate them into a single [Vec].
     #[inline]
-    fn try_read_n_from<L: Locale, S: BufReadExt>(
+    fn try_read_n_from<F: Format, S: BufReadExt>(
         stream: &mut S,
         n: usize,
-        locale: &L,
+        format: &F,
     ) -> Result<Vec<Self>, ReadFromError<Self>> {
         let mut res = Vec::with_capacity(n);
         for _ in 0..n {
-            res.push(Self::try_read_from(stream, locale)?);
+            res.push(Self::try_read_from(stream, format)?);
         }
         Ok(res)
     }
     /// Read `m * n` elements from `self`, parse into `Self` and aggregate them into a single [Mat].
     #[inline]
-    fn try_read_m_n_from<L: Locale, S: BufReadExt>(
+    fn try_read_m_n_from<F: Format, S: BufReadExt>(
         stream: &mut S,
         m: usize,
         n: usize,
-        locale: &L,
+        format: &F,
     ) -> Result<Mat<Self>, ReadFromError<Self>> {
         let mut res = Mat::with_capacity(m);
         for _ in 0..m {
-            res.push(Self::try_read_n_from(stream, n, locale)?);
+            res.push(Self::try_read_n_from(stream, n, format)?);
         }
         Ok(res)
     }
@@ -57,11 +57,11 @@ impl<T: ReadOneFrom> ReadFrom for T {
     type ParseError = <Self as ReadOneFrom>::ParseError;
 
     #[inline]
-    fn try_read_from<L: Locale, S: BufReadExt>(
+    fn try_read_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<T, ReadFromError<Self>> {
-        Self::try_read_one_from(stream, locale)
+        Self::try_read_one_from(stream, format)
     }
 }
 
@@ -69,11 +69,11 @@ impl<T: ReadFrom, const N: usize> ReadFrom for [T; N] {
     type ParseError = <T as ReadFrom>::ParseError;
 
     #[inline]
-    fn try_read_from<L: Locale, S: BufReadExt>(
+    fn try_read_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadFromError<Self>> {
-        array_try_from_fn(|| T::try_read_from(stream, locale))
+        array_try_from_fn(|| T::try_read_from(stream, format))
     }
 }
 
@@ -81,11 +81,11 @@ impl<T: ReadFrom, const N: usize> ReadFrom for Box<[T; N]> {
     type ParseError = <T as ReadFrom>::ParseError;
 
     #[inline]
-    fn try_read_from<L: Locale, S: BufReadExt>(
+    fn try_read_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Box<[T; N]>, ReadFromError<Self>> {
-        let res = T::try_read_n_from(stream, N, locale)?
+        let res = T::try_read_n_from(stream, N, format)?
             .into_boxed_slice()
             .try_into();
         let res = unsafe { res.unwrap_unchecked() };
@@ -104,10 +104,10 @@ impl<T: ReadOneFrom> ReadFrom for Vec<T> {
     type ParseError = <T as ReadOneFrom>::ParseError;
 
     #[inline]
-    fn try_read_from<L: Locale, S: BufReadExt>(
+    fn try_read_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Vec<T>, ReadFromError<Self>> {
-        T::try_read_some_in_line_from(stream, locale)
+        T::try_read_some_in_line_from(stream, format)
     }
 }
diff --git a/src/read/read_into.rs b/src/read/read_into.rs
index 67eebab..ac3c30b 100644
--- a/src/read/read_into.rs
+++ b/src/read/read_into.rs
@@ -1,6 +1,6 @@
 use crate::{unwrap, BufReadExt, Mat, ReadFrom};
 
-use super::{locale::ASCII, read_from::ReadFromError};
+use super::{fmt::Default, read_from::ReadFromError};
 
 /// The opposite of [ReadFrom].
 pub trait ReadInto<T>: BufReadExt {
@@ -51,16 +51,16 @@ where
 
     #[inline]
     fn try_read(&mut self) -> Result<U, Self::Error> {
-        U::try_read_from(self, &ASCII)
+        U::try_read_from(self, &Default)
     }
 
     #[inline]
     fn try_read_n(&mut self, n: usize) -> Result<Vec<U>, Self::Error> {
-        U::try_read_n_from(self, n, &ASCII)
+        U::try_read_n_from(self, n, &Default)
     }
 
     #[inline]
     fn try_read_m_n(&mut self, m: usize, n: usize) -> Result<Mat<U>, Self::Error> {
-        U::try_read_m_n_from(self, m, n, &ASCII)
+        U::try_read_m_n_from(self, m, n, &Default)
     }
 }
diff --git a/src/read/read_one_from.rs b/src/read/read_one_from.rs
index ccba7f9..add8b0d 100644
--- a/src/read/read_one_from.rs
+++ b/src/read/read_one_from.rs
@@ -1,6 +1,6 @@
 use super::{
+    fmt::Format,
     iter::{ReadAll, ReadAllIn},
-    locale::Locale,
 };
 use crate::{BufReadExt, ReadError};
 
@@ -30,79 +30,76 @@ pub trait ReadOneFrom: Sized {
 
     /// Read from `stream` and parse into `Self`.
     #[inline]
-    fn try_read_one_from<L: Locale, S: BufReadExt>(
+    fn try_read_one_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadError<Self::ParseError>> {
-        let s = stream.try_get_string_some(locale.whitespace_chars())?;
+        let s = stream.try_get_string_some(format.skipped_chars())?;
         Self::parse(s)
     }
 
     /// Read an element in a single non-whitespace character from `stream`, parse into `Self`.
     #[inline]
-    fn try_read_in_char_from<L: Locale, S: BufReadExt>(
+    fn try_read_in_char_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadError<Self::ParseError>> {
-        let s = stream.try_get_non(locale.whitespace_chars())?;
+        let s = stream.try_get_non(format.skipped_chars())?;
         Self::parse(s.encode_utf8(&mut [0; 4]))
     }
 
     /// Read an element in the remained line from `stream`, parse into `Self`.
     #[inline]
-    fn try_read_in_line_trimmed_from<L: Locale, S: BufReadExt>(
+    fn try_read_in_line_trimmed_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadError<Self::ParseError>> {
         let s = stream
-            .try_get_line_trimmed(locale.whitespace_chars())?
+            .try_get_line_trimmed(format.skipped_chars())?
             .trim_start();
         Self::parse(s)
     }
 
     /// Read an element in a single trimmed line that is not empty from `stream`, parse into `Self`.
     #[inline]
-    fn try_read_in_line_some_trimmed_from<L: Locale, S: BufReadExt>(
+    fn try_read_in_line_some_trimmed_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Self, ReadError<Self::ParseError>> {
         let s = stream
-            .try_get_line_some_trimmed(locale.whitespace_chars())?
+            .try_get_line_some_trimmed(format.skipped_chars())?
             .trim_start();
         Self::parse(s)
     }
 
     /// Read all remaining elements from `stream` into a [Vec] of `Self`.
     #[inline]
-    fn try_read_all_from<L: Locale, S: BufReadExt>(
+    fn try_read_all_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Vec<Self>, ReadError<Self::ParseError>> {
-        ReadAll::<L, S, Self>::new(stream, locale).collect()
+        ReadAll::<F, S, Self>::new(stream, format).collect()
     }
 
     /// Read all elements in current line from `stream` into a [Vec] of `Self`.
     #[inline]
-    fn try_read_any_in_line_from<L: Locale, S: BufReadExt>(
+    fn try_read_any_in_line_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Vec<Self>, ReadError<Self::ParseError>> {
-        ReadAllIn::<L, Self>::new(
-            stream.try_get_line_trimmed(locale.whitespace_chars())?,
-            locale,
-        )
-        .collect()
+        ReadAllIn::<F, Self>::new(stream.try_get_line_trimmed(format.skipped_chars())?, format)
+            .collect()
     }
 
     /// Read all elements in a non-empty line from `stream` into a [Vec] of `Self`.
     #[inline]
-    fn try_read_some_in_line_from<L: Locale, S: BufReadExt>(
+    fn try_read_some_in_line_from<F: Format, S: BufReadExt>(
         stream: &mut S,
-        locale: &L,
+        format: &F,
     ) -> Result<Vec<Self>, ReadError<Self::ParseError>> {
-        ReadAllIn::<L, Self>::new(
-            stream.try_get_line_some_trimmed(locale.whitespace_chars())?,
-            locale,
+        ReadAllIn::<F, Self>::new(
+            stream.try_get_line_some_trimmed(format.skipped_chars())?,
+            format,
         )
         .collect()
     }
diff --git a/src/read/read_one_into.rs b/src/read/read_one_into.rs
index a6582da..2afc87c 100644
--- a/src/read/read_one_into.rs
+++ b/src/read/read_one_into.rs
@@ -1,6 +1,6 @@
 use crate::{stream, unwrap, BufReadExt, ReadOneFrom, ReadOneFromError};
 
-use super::locale::ASCII;
+use super::fmt::Default;
 
 /// The opposite of [ReadOneFrom].
 pub trait ReadOneInto<T> {
@@ -87,36 +87,36 @@ impl<T: ReadOneFrom, U: BufReadExt> ReadOneInto<T> for U {
 
     #[inline]
     fn try_read_one(&mut self) -> Result<T, Self::Error> {
-        T::try_read_one_from(self, &ASCII)
+        T::try_read_one_from(self, &Default)
     }
 
     #[inline]
     fn try_read_in_char(&mut self) -> Result<T, Self::Error> {
-        T::try_read_in_char_from(self, &ASCII)
+        T::try_read_in_char_from(self, &Default)
     }
 
     #[inline]
     fn try_read_in_line_trimmed(&mut self) -> Result<T, Self::Error> {
-        T::try_read_in_line_trimmed_from(self, &ASCII)
+        T::try_read_in_line_trimmed_from(self, &Default)
     }
 
     #[inline]
     fn try_read_in_line_some_trimmed(&mut self) -> Result<T, Self::Error> {
-        T::try_read_in_line_some_trimmed_from(self, &ASCII)
+        T::try_read_in_line_some_trimmed_from(self, &Default)
     }
 
     #[inline]
     fn try_read_all(&mut self) -> Result<Vec<T>, Self::Error> {
-        T::try_read_all_from(self, &ASCII)
+        T::try_read_all_from(self, &Default)
     }
 
     #[inline]
     fn try_read_any_in_line(&mut self) -> Result<Vec<T>, Self::Error> {
-        T::try_read_any_in_line_from(self, &ASCII)
+        T::try_read_any_in_line_from(self, &Default)
     }
 
     #[inline]
     fn try_read_some_in_line(&mut self) -> Result<Vec<T>, Self::Error> {
-        T::try_read_some_in_line_from(self, &ASCII)
+        T::try_read_some_in_line_from(self, &Default)
     }
 }
diff --git a/src/read/tuple.rs b/src/read/tuple.rs
index 4f61f6e..081dd9f 100644
--- a/src/read/tuple.rs
+++ b/src/read/tuple.rs
@@ -1,4 +1,4 @@
-use crate::{locale::Locale, BufReadExt, ReadFrom, ReadFromError};
+use crate::{fmt::Format, BufReadExt, ReadFrom, ReadFromError};
 use std::fmt::{self, Display};
 
 macro_rules! impl_read_into_for_tuple {
@@ -7,7 +7,7 @@ macro_rules! impl_read_into_for_tuple {
         impl ReadFrom for () {
             type ParseError = $e;
             #[inline]
-            fn try_read_from<L: Locale, S: BufReadExt>(_stream: &mut S, _locale: &L) -> Result<(), ReadFromError<Self>> {
+            fn try_read_from<F: Format, S: BufReadExt>(_stream: &mut S, _format: &F) -> Result<(), ReadFromError<Self>> {
                 Ok(())
             }
         }
@@ -27,8 +27,8 @@ macro_rules! impl_read_into_for_tuple {
         impl<$($t: ReadFrom, )+> ReadFrom for ( $($t, )+ ) {
             type ParseError = $e<$(<$t as ReadFrom>::ParseError, )+>;
             #[inline]
-            fn try_read_from<L: Locale, S: BufReadExt>(stream: &mut S, locale: &L) -> Result<($($t, )+), ReadFromError<Self>> {
-                Ok(( $(<$t as ReadFrom>::try_read_from(stream, locale).map_err(|err| match err {
+            fn try_read_from<F: Format, S: BufReadExt>(stream: &mut S, format: &F) -> Result<($($t, )+), ReadFromError<Self>> {
+                Ok(( $(<$t as ReadFrom>::try_read_from(stream, format).map_err(|err| match err {
                     ReadFromError::<$t>::IOError(e) => ReadFromError::<Self>::IOError(e),
                     ReadFromError::<$t>::EOF => ReadFromError::<Self>::EOF,
                     ReadFromError::<$t>::EOL => ReadFromError::<Self>::EOL,
diff --git a/src/stream/input_stream.rs b/src/stream/input_stream.rs
index 2de81f5..3b61584 100644
--- a/src/stream/input_stream.rs
+++ b/src/stream/input_stream.rs
@@ -57,7 +57,7 @@ impl<B: BufRead> BufReadExt<char> for InputStream<B> {
 #[cfg(test)]
 mod tests {
     use crate::{
-        locale::{Locale, ASCII},
+        fmt::{Format, Default},
         stream::{error::StreamError, input_stream::InputStream},
         BufReadExt,
     };
@@ -106,31 +106,31 @@ mod tests {
         let mut stream = InputStream::new(Cursor::new(s));
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "Hello,"
         );
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "world!"
         );
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "Hello,"
         );
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "Rust!"
         );
         assert!(matches!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap_err(),
             StreamError::Eof
         ),);
diff --git a/src/stream/line_buf.rs b/src/stream/line_buf.rs
index 420226c..b5f0264 100644
--- a/src/stream/line_buf.rs
+++ b/src/stream/line_buf.rs
@@ -46,7 +46,7 @@ impl BufReadExt<char> for LineBuf<'_> {
 #[cfg(test)]
 mod tests {
     use crate::{
-        locale::{Locale, ASCII},
+        fmt::{Format, Default},
         stream::{error::StreamError, line_buf::LineBuf},
         BufReadExt,
     };
@@ -71,7 +71,7 @@ mod tests {
         assert!(matches!(stream.try_get().unwrap_err(), StreamError::Eol));
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap_err()
                 .to_string(),
             StreamError::Eol.to_string(),
@@ -84,25 +84,25 @@ mod tests {
         let mut stream = LineBuf::new(s);
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "Hello,"
         );
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap(),
             "world!"
         );
         assert!(matches!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap_err(),
             StreamError::Eol,
         ));
         assert_eq!(
             stream
-                .try_get_string_some(ASCII.whitespace_chars())
+                .try_get_string_some(Default.skipped_chars())
                 .unwrap_err()
                 .to_string(),
             StreamError::Eol.to_string(),
diff --git a/src/stream/tests.rs b/src/stream/tests.rs
index a00df99..54ba042 100644
--- a/src/stream/tests.rs
+++ b/src/stream/tests.rs
@@ -3,7 +3,7 @@ use super::{
     line_buf::LineBuf,
 };
 use crate::{
-    locale::{Locale, ASCII},
+    fmt::{Format, Default},
     unwrap, BufReadExt, InputStream,
 };
 use std::io::Cursor;
@@ -16,7 +16,7 @@ where
     for<'a> &'a [Char]: ext::Pattern<Item = Char>,
     for<'a> &'a str: ext::StrExt<'a, Char>,
     char: From<Char>,
-    ASCII: Locale<Char>,
+    Default: Format<Char>,
 {
     let c = unwrap!(stream.try_get());
     assert_eq!(c, 'H');
@@ -41,7 +41,7 @@ where
     let s = unwrap!(stream.try_get_until_in_line(&['!'].map(Into::into)));
     assert_eq!(s, ", world");
 
-    let s = unwrap!(stream.try_get_string_some(ASCII.whitespace_chars()));
+    let s = unwrap!(stream.try_get_string_some(Default.skipped_chars()));
     assert_eq!(s, "!");
 
     let c = unwrap!(stream.try_peek());
diff --git a/tests/array.rs b/tests/array.rs
index 28ee8ef..0816301 100644
--- a/tests/array.rs
+++ b/tests/array.rs
@@ -1,5 +1,5 @@
 use iof::*;
-use locale::ASCII;
+use fmt::Default;
 use std::io::Cursor;
 
 #[test]
@@ -10,8 +10,8 @@ fn read_array_0() {
     let vec: [i32; 0] = reader.read();
     assert_eq!(vec, []);
 
-    assert!(<[u32; 0]>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<[u32; 1]>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<[u32; 0]>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<[u32; 1]>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -22,8 +22,8 @@ fn read_boxed_array_0() {
     let vec: Box<[i32; 0]> = reader.read();
     assert_eq!(vec.as_ref(), &[]);
 
-    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -34,8 +34,8 @@ fn read_array_1() {
     let vec: [i32; 1] = reader.read();
     assert_eq!(vec, [1]);
 
-    assert!(<[u32; 0]>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<[u32; 1]>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<[u32; 0]>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<[u32; 1]>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -46,8 +46,8 @@ fn read_boxed_array_1() {
     let vec: Box<[i32; 1]> = reader.read();
     assert_eq!(vec.as_ref(), &[1]);
 
-    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -58,8 +58,8 @@ fn read_array_4() {
     let vec: [i32; 4] = reader.read();
     assert_eq!(vec, [1, -2, 3, -4]);
 
-    assert!(<[u32; 0]>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<[u32; 1]>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<[u32; 0]>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<[u32; 1]>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -70,8 +70,8 @@ fn read_boxed_array_4() {
     let vec: Box<[i32; 4]> = reader.read();
     assert_eq!(vec.as_ref(), &[1, -2, 3, -4]);
 
-    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -82,8 +82,8 @@ fn try_read_array_4() {
     let vec: [i32; 4] = reader.try_read().unwrap();
     assert_eq!(vec, [1, -2, 3, -4]);
 
-    assert!(<[u32; 0]>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<[u32; 1]>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<[u32; 0]>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<[u32; 1]>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -94,8 +94,8 @@ fn try_read_boxed_array_4() {
     let vec: Box<[i32; 4]> = reader.try_read().unwrap();
     assert_eq!(vec.as_ref(), &[1, -2, 3, -4]);
 
-    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &ASCII).is_ok());
-    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<Box<[u32; 0]>>::try_read_from(&mut reader, &Default).is_ok());
+    assert!(<Box<[u32; 1]>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
diff --git a/tests/buffer.rs b/tests/buffer.rs
index 1d79018..acea603 100644
--- a/tests/buffer.rs
+++ b/tests/buffer.rs
@@ -1,5 +1,5 @@
 use iof::{
-    locale::{Locale, ASCII},
+    fmt::{Format, Default},
     unwrap, BufReadExt, InputStream,
 };
 use std::io::Cursor;
@@ -151,7 +151,7 @@ fn read_string() {
     let mut reader = InputStream::new(reader);
 
     assert!(reader
-        .try_get_string_some(ASCII.whitespace_chars())
+        .try_get_string_some(Default.skipped_chars())
         .is_err());
 }
 
@@ -178,7 +178,7 @@ fn read_one_then_read_line() {
     let mut reader = InputStream::new(reader);
 
     let a = reader
-        .try_get_string_some(ASCII.whitespace_chars())
+        .try_get_string_some(Default.skipped_chars())
         .unwrap();
     assert_eq!(a, "1");
 
@@ -186,7 +186,7 @@ fn read_one_then_read_line() {
     assert_eq!(b, "");
 
     let a = reader
-        .try_get_string_some(ASCII.whitespace_chars())
+        .try_get_string_some(Default.skipped_chars())
         .unwrap();
     assert_eq!(a, "2");
 
@@ -194,7 +194,7 @@ fn read_one_then_read_line() {
     assert_eq!(b, " ");
 
     let a = reader
-        .try_get_string_some(ASCII.whitespace_chars())
+        .try_get_string_some(Default.skipped_chars())
         .unwrap();
     assert_eq!(a, "3");
 
@@ -202,7 +202,7 @@ fn read_one_then_read_line() {
     assert_eq!(b, " ");
 
     assert!(reader
-        .try_get_string_some(ASCII.whitespace_chars())
+        .try_get_string_some(Default.skipped_chars())
         .is_err());
     assert!(reader.try_get_line().is_err());
     assert!(reader.try_get_line_some().is_err());
diff --git a/tests/ill_buffer.rs b/tests/ill_buffer.rs
index ead6bd6..d5228e6 100644
--- a/tests/ill_buffer.rs
+++ b/tests/ill_buffer.rs
@@ -1,5 +1,5 @@
 use iof::{
-    locale::{Locale, ASCII},
+    fmt::{Format, Default},
     show, unwrap, BufReadExt, InputStream, ReadInto, ReadOneInto, WriteInto,
 };
 use std::io::{self, Cursor};
@@ -29,7 +29,7 @@ impl io::Write for IllBuffer {
 #[test]
 fn try_get_string_some() {
     let mut buf = InputStream::new(IllBuffer);
-    let res: Result<&str, _> = buf.try_get_string_some(ASCII.whitespace_chars());
+    let res: Result<&str, _> = buf.try_get_string_some(Default.skipped_chars());
     assert!(res.is_err());
     let err = res.unwrap_err();
     assert_eq!(err.to_string(), "ill buffer");
@@ -38,7 +38,7 @@ fn try_get_string_some() {
 #[test]
 fn try_get_line_some_trimmed() {
     let mut buf = InputStream::new(IllBuffer);
-    let res: Result<&str, _> = buf.try_get_line_some_trimmed(ASCII.whitespace_chars());
+    let res: Result<&str, _> = buf.try_get_line_some_trimmed(Default.skipped_chars());
     assert!(res.is_err());
     let err = res.unwrap_err();
     assert_eq!(err.to_string(), "ill buffer");
diff --git a/tests/integers.rs b/tests/integers.rs
index ee07d02..93f3366 100644
--- a/tests/integers.rs
+++ b/tests/integers.rs
@@ -1,6 +1,6 @@
 use dimension::Dimension;
 use iof::*;
-use locale::ASCII;
+use fmt::Default;
 use std::io::Cursor;
 
 #[test]
@@ -39,7 +39,7 @@ fn try_read_single_3() {
     let c: u32 = reader.try_read_one().unwrap();
     assert_eq!(c, 3);
 
-    assert!(<u32>::try_read_one_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_one_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -56,7 +56,7 @@ fn read_single_3() {
     let c: u32 = reader.read_one();
     assert_eq!(c, 3);
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -73,7 +73,7 @@ fn read_3() {
     let c: u32 = reader.read();
     assert_eq!(c, 3);
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -90,7 +90,7 @@ fn read_char_3() {
     let c: u32 = reader.read_in_char();
     assert_eq!(c, 3);
 
-    assert!(<u32>::try_read_in_char_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_in_char_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -107,7 +107,7 @@ fn read_char_in_3_lines() {
     let c: u32 = reader.read_in_char();
     assert_eq!(c, 3);
 
-    assert!(<u32>::try_read_in_char_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_in_char_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -127,7 +127,7 @@ fn read_one_then_all_in_line() {
     let d: Vec<u32> = reader.read_any_in_line();
     assert_eq!(d, [5, 6, 7]);
 
-    assert!(<u32>::try_read_any_in_line_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_any_in_line_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -144,7 +144,7 @@ fn read_one_then_all_in_line_some() {
     let c: Vec<u32> = reader.read_some_in_line();
     assert_eq!(c, [5, 6, 7]);
 
-    assert!(<u32>::try_read_some_in_line_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_some_in_line_from(&mut reader, &Default).is_err());
 }
 #[test]
 fn read_all() {
@@ -154,7 +154,7 @@ fn read_all() {
     let a: Vec<u32> = reader.read_all();
     assert_eq!(a, [1, 2, 3, 4, 5, 6, 7]);
 
-    assert!(<u32>::try_read_one_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_one_from(&mut reader, &Default).is_err());
 }
 
 #[test]
diff --git a/tests/mat.rs b/tests/mat.rs
index 7ba7808..8624249 100644
--- a/tests/mat.rs
+++ b/tests/mat.rs
@@ -1,5 +1,5 @@
+use fmt::{Default, CSV};
 use iof::*;
-use locale::ASCII;
 use std::{io::Cursor, vec};
 
 #[test]
@@ -41,7 +41,7 @@ fn read_m_n() {
 
     assert_eq!(unwrap!(mat.try_write_into_string()), "1 2 3\n4 5 6");
 
-    assert!(<u32>::try_read_n_from(&mut reader, 1, &ASCII).is_err());
+    assert!(<u32>::try_read_n_from(&mut reader, 1, &Default).is_err());
 }
 
 #[test]
@@ -64,7 +64,7 @@ fn read_same_rows() {
 
     assert_eq!(unwrap!(mat.try_write_into_string()), "2 3 2\n2 3 2\n2 3 2");
 
-    assert!(<u32>::try_read_m_n_from(&mut reader, 1, 1, &ASCII).is_err());
+    assert!(<u32>::try_read_m_n_from(&mut reader, 1, 1, &Default).is_err());
 }
 
 #[test]
@@ -81,7 +81,7 @@ fn read_all_same() {
 
     assert_eq!(unwrap!(mat.try_write_into_string()), "2 2 2\n2 2 2");
 
-    assert!(<u32>::try_read_m_n_from(&mut reader, 1, 1, &ASCII).is_err());
+    assert!(<u32>::try_read_m_n_from(&mut reader, 1, 1, &Default).is_err());
 }
 
 #[test]
@@ -98,7 +98,26 @@ fn read_char_mat() {
 
     assert_eq!(unwrap!(mat.try_write_into_string()), "123\n456");
 
-    assert!(<char>::try_read_m_n_from(&mut reader, 1, 1, &ASCII).is_err());
+    assert!(<char>::try_read_m_n_from(&mut reader, 1, 1, &Default).is_err());
+}
+
+#[test]
+fn macro_read_mat() {
+    let reader = Cursor::new("123\n456".as_bytes());
+    let mut reader = InputStream::new(reader);
+
+    let mat: Mat<char> = read!(2, 3; src = &mut reader; fmt = Default);
+    assert_eq!(mat, [['1', '2', '3'], ['4', '5', '6']]);
+
+    let reader = Cursor::new("123\n456".as_bytes());
+    let mut reader = InputStream::new(reader);
+    let mat: Vec<usize> = read!(2; src = &mut reader; fmt = Default);
+    assert_eq!(mat, [123, 456]);
+
+    let reader = Cursor::new("1,2,3\n4,5,6".as_bytes());
+    let mut reader = InputStream::new(reader);
+    let mat: Mat<char> = read!(2, 3; src = &mut reader; fmt = CSV);
+    assert_eq!(mat, [['1', '2', '3'], ['4', '5', '6']]);
 }
 
 #[test]
diff --git a/tests/string.rs b/tests/string.rs
index 6097a76..bfe4d9d 100644
--- a/tests/string.rs
+++ b/tests/string.rs
@@ -1,4 +1,4 @@
-use iof::{locale::ASCII, show, unwrap, InputStream, ReadFrom, ReadInto, ReadOneFrom, ReadOneInto};
+use iof::{fmt::Default, show, unwrap, InputStream, ReadFrom, ReadInto, ReadOneFrom, ReadOneInto};
 use std::io::Cursor;
 
 #[allow(dead_code)]
@@ -19,7 +19,7 @@ fn read_strings() {
     let world: String = reader.read();
     assert_eq!(hello, "Hello,");
     assert_eq!(world, "World!");
-    assert!(<String>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -29,7 +29,7 @@ fn read_string_vec() {
 
     let strings: Vec<String> = reader.read_n(4);
     assert_eq!(strings, vec!["There", "are", "4", "strings."]);
-    assert!(<String>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -39,7 +39,7 @@ fn read_all_strings() {
 
     let strings: Vec<String> = reader.read_all();
     assert_eq!(strings, vec!["There", "are", "4", "strings."]);
-    assert!(<String>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -49,7 +49,7 @@ fn read_line() {
 
     let strings: String = reader.read_in_line_some_trimmed();
     assert_eq!(strings, "There are 4 strings.");
-    assert!(<String>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -63,7 +63,7 @@ fn read_in_line() {
     let b: String = reader.read_in_line_trimmed();
     assert_eq!(b, "There are 3 lines.");
 
-    assert!(<String>::try_read_some_in_line_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_some_in_line_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -73,7 +73,7 @@ fn read_in_line_some_trimmed_spaces() {
 
     let s: String = reader.read_in_line_some_trimmed();
     assert_eq!(s, "s");
-    assert!(<String>::try_read_some_in_line_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_some_in_line_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -111,7 +111,7 @@ fn read_unicode() {
     let s: String = reader.read();
     assert_eq!(s, "καλημέρα");
 
-    assert!(<String>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -131,7 +131,7 @@ fn read_in_line_trimmed_unicode() {
     let s: String = reader.read_in_line_trimmed();
     assert_eq!(s, "καλημέρα");
 
-    assert!(<String>::try_read_in_line_trimmed_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_in_line_trimmed_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -151,7 +151,7 @@ fn read_in_line_some_unicode() {
     let s: String = reader.read_in_line_some_trimmed();
     assert_eq!(s, "καλημέρα");
 
-    assert!(<String>::try_read_in_line_some_trimmed_from(&mut reader, &ASCII).is_err());
+    assert!(<String>::try_read_in_line_some_trimmed_from(&mut reader, &Default).is_err());
 }
 
 #[test]
diff --git a/tests/tuple.rs b/tests/tuple.rs
index 9a1eefb..5d964f8 100644
--- a/tests/tuple.rs
+++ b/tests/tuple.rs
@@ -1,5 +1,5 @@
 use iof::*;
-use locale::ASCII;
+use fmt::Default;
 use std::{io::Cursor, str::from_utf8};
 
 #[test]
@@ -10,7 +10,7 @@ fn read_tuple_3() {
     let vec: (u32, u32, u32) = reader.read();
     assert_eq!(vec, (1, 2, 3));
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -62,7 +62,7 @@ fn read_tuple_12() {
     let vec: (u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32, u32) = reader.read();
     assert_eq!(vec, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12));
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
diff --git a/tests/vec.rs b/tests/vec.rs
index 526fcb6..d249d44 100644
--- a/tests/vec.rs
+++ b/tests/vec.rs
@@ -1,5 +1,5 @@
+use fmt::{skip, Default};
 use iof::*;
-use locale::ASCII;
 use std::{collections::BTreeSet, io::Cursor, str::from_utf8};
 
 #[test]
@@ -11,7 +11,7 @@ fn read_n() {
     assert_eq!(vec, &[1, 2, 3]);
     assert_eq!(vec.sep_by(&" ").to_string(), "1 2 3");
 
-    assert!(<u32>::try_read_n_from(&mut reader, 1, &ASCII).is_err());
+    assert!(<u32>::try_read_n_from(&mut reader, 1, &Default).is_err());
 }
 
 #[test]
@@ -28,7 +28,7 @@ fn read() {
     let c: Vec<u32> = reader.read();
     assert_eq!(c, [7, 8]);
 
-    assert!(<Vec<u32>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<Vec<u32>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -42,7 +42,7 @@ fn read_one_then_read_2() {
     let b: Vec<u32> = reader.read();
     assert_eq!(b, [2, 3]);
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -59,9 +59,9 @@ fn read_one_then_read_0() {
     let a: u32 = reader.read_one();
     assert_eq!(a, 3);
 
-    assert!(<u32>::try_read_from(&mut reader, &ASCII).is_err());
-    assert!(<Vec<u32>>::try_read_from(&mut reader, &ASCII).is_err());
-    assert!(<Vec<u32>>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_from(&mut reader, &Default).is_err());
+    assert!(<Vec<u32>>::try_read_from(&mut reader, &Default).is_err());
+    assert!(<Vec<u32>>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -77,7 +77,7 @@ fn read_any_in_line() {
     let a: Vec<u32> = reader.read_any_in_line();
     assert_eq!(a, vec![1, 2, 3]);
 
-    assert!(<u32>::try_read_any_in_line_from(&mut reader, &ASCII).is_err());
+    assert!(<u32>::try_read_any_in_line_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -106,7 +106,7 @@ fn read_char_3() {
     let a: Vec<char> = reader.read();
     assert_eq!(a, vec!['1', '2', '3']);
 
-    assert!(<char>::try_read_from(&mut reader, &ASCII).is_err());
+    assert!(<char>::try_read_from(&mut reader, &Default).is_err());
 }
 
 #[test]
@@ -140,6 +140,27 @@ fn read_all_digit_error() {
     let _: Vec<u32> = reader.read_all();
 }
 
+#[test]
+fn macro_read_vec() {
+    let reader = Cursor::new("1,2,3\n4,5,6".as_bytes());
+    let mut reader = InputStream::new(reader);
+
+    let vec: Vec<char> = read!(; src = &mut reader; fmt = skip([]));
+    assert_eq!(vec, ['1', ',', '2', ',', '3']);
+
+    let vec: Vec<char> = read!(; src = &mut reader; fmt = skip([]));
+    assert_eq!(vec, ['4', ',', '5', ',', '6']);
+
+    let reader = Cursor::new("1 2 3\n4 5 6".as_bytes());
+    let mut reader = InputStream::new(reader);
+
+    let vec: Vec<char> = read!(; src = &mut reader; fmt = skip([]));
+    assert_eq!(vec, ['1', ' ', '2', ' ', '3']);
+
+    let vec: Vec<char> = read!(; src = &mut reader; fmt = skip([]));
+    assert_eq!(vec, ['4', ' ', '5', ' ', '6']);
+}
+
 #[test]
 fn display() {
     let s = Vec::from([1, 2, 3]);