add docs for strconv

Author: Yu-zh

strconv/decimal.mbt

@@ -58,7 +58,26 @@ pub fn Decimal::from_int64(v : Int64) -> Decimal {
 }
 
 ///|
-/// Create a decimal from number string.
+/// Parse a string into a decimal number. The string must contain at least one of:
+/// - An integer part (decimal digits)
+/// - A decimal point followed by a fractional part (decimal digits)
+/// - An exponent part ('e' or 'E' followed by an optional sign and decimal digits)
+///
+/// The string may optionally start with a sign ('+' or '-').
+/// For readability, underscores may appear between digits.
+///
+/// Examples:
+/// ```
+/// inspect!(parse_decimal!("123"), content="123")
+/// inspect!(parse_decimal!("12.34"), content="12.34")
+/// inspect!(parse_decimal!(".123"), content="0.123")
+/// inspect!(parse_decimal!("1e5"), content="100000")
+/// inspect!(parse_decimal!("1.2e-3"), content="0.0012")
+/// inspect!(parse_decimal!("1_234.5"), content="1234.5")
+/// ```
+///
+/// An exponent value exp scales the mantissa (significand) by 10^exp.
+/// For example, "1.23e2" represents 1.23 × 10² = 123.
 pub fn parse_decimal(str : String) -> Decimal!StrConvError {
   parse_decimal_from_view!(str[:])
 }
@@ -544,7 +563,7 @@ fn trim(self : Decimal) -> Unit {
 }
 
 ///|
-impl Show for Decimal with output(self, logger) {
+pub impl Show for Decimal with output(self, logger) {
   if self.digits_num == 0 {
     logger.write_char('0')
     return

strconv/double.mbt

@@ -46,6 +46,27 @@ let max_exponent_disguised_fast_path : Int64 = 37L
 let max_mantissa_fast_path : UInt64 = 2UL << mantissa_explicit_bits
 
 ///|
+/// Parse a string into a double precision floating point number. The string
+/// must contain at least one of:
+/// - An integer part (decimal digits)
+/// - A decimal point followed by a fractional part (decimal digits)
+/// - An exponent part ('e' or 'E' followed by an optional sign and decimal digits)
+///
+/// The string may optionally start with a sign ('+' or '-').
+/// For readability, underscores may appear between digits.
+///
+/// Examples:
+/// ```
+/// inspect!(parse_double!("123"), content="123")
+/// inspect!(parse_double!("12.34"), content="12.34")
+/// inspect!(parse_double!(".123"), content="0.123")
+/// inspect!(parse_double!("1e5"), content="100000")
+/// inspect!(parse_double!("1.2e-3"), content="0.0012")
+/// inspect!(parse_double!("1_234.5"), content="1234.5")
+/// ```
+///
+/// An exponent value exp scales the mantissa (significand) by 10^exp.
+/// For example, "1.23e2" represents 1.23 × 10² = 123.
 pub fn parse_double(str : String) -> Double!StrConvError {
   if str.length() == 0 {
     syntax_err!()

strconv/int.mbt

@@ -55,8 +55,27 @@ fn check_and_consume_base(
 }
 
 ///|
-/// Parse a string in the given base (0, 2 to 36), return a Int64 number or an error.
-/// If the `~base` argument is 0, the base will be inferred by the prefix.
+/// Parses a string into an Int64 number using the specified base, or returns an error.
+/// The base must be 0 or between 2 and 36 (inclusive). If base is 0, it will be 
+/// inferred from the string prefix:
+///   - "0x" or "0X" for base 16 (hex)
+///   - "0o" or "0O" for base 8 (octal) 
+///   - "0b" or "0B" for base 2 (binary)
+///   - Default is base 10 (decimal)
+/// For readability, underscores may appear after base prefixes or between digits.
+/// These underscores do not affect the value.
+/// Examples:
+/// ```
+/// inspect!(parse_int64!("123"), content="123")
+/// inspect!(parse_int64!("0xff", base=0), content="255") 
+/// inspect!(parse_int64!("0o10"), content="8")
+/// inspect!(parse_int64!("0b1010"), content="10")
+/// inspect!(parse_int64!("1_234"), content="1234")
+/// inspect!(parse_int64!("-123"), content="-123")
+/// inspect!(parse_int64!("ff", base=16), content="255")
+/// inspect!(parse_int64!("zz", base=36), content="1295")
+/// ```
+/// 
 pub fn parse_int64(str : String, base~ : Int = 0) -> Int64!StrConvError {
   guard str != "" else { syntax_err!() }
   let (neg, rest) = match str[:] {

strconv/strconv.mbti

@@ -26,6 +26,7 @@ impl Decimal {
   shift(Self, Int) -> Unit
   to_double(Self) -> Double!StrConvError
 }
+impl Show for Decimal
 
 pub(all) type! StrConvError String
 impl Show for StrConvError

strconv/uint.mbt

@@ -19,8 +19,26 @@ const UINT_MAX : UInt = 0xffffffff
 const UINT64_MAX : UInt64 = 0xffffffffffffffffUL
 
 ///|
-/// Parse a string in the given base (0, 2 to 36), return an UInt64 number or an error.
-/// If the `~base` argument is 0, the base will be inferred by the prefix.
+/// Parses a string into a UInt64 number using the specified base, or returns an error.
+/// The base must be 0 or between 2 and 36 (inclusive). If base is 0, it will be 
+/// inferred from the string prefix:
+///   - "0x" or "0X" for base 16 (hex)
+///   - "0o" or "0O" for base 8 (octal)
+///   - "0b" or "0B" for base 2 (binary)
+///   - Default is base 10 (decimal)
+/// For readability, underscores may appear after base prefixes or between digits.
+/// These underscores do not affect the value.
+/// Examples:
+/// ```
+/// inspect!(parse_uint64!("123"), content="123")
+/// inspect!(parse_uint64!("0xff", base=0), content="255")
+/// inspect!(parse_uint64!("0o10"), content="8")
+/// inspect!(parse_uint64!("0b1010"), content="10")
+/// inspect!(parse_uint64!("1_234"), content="1234")
+/// inspect!(parse_uint64!("ff", base=16), content="255")
+/// inspect!(parse_uint64!("zz", base=36), content="1295")
+/// ```
+/// 
 pub fn parse_uint64(str : String, base~ : Int = 0) -> UInt64!StrConvError {
   guard str != "" else { syntax_err!() }
   match str[:] {