rust 58 lines · 8 steps

Parsing duration strings safely in Rust

A single-pass parser turns strings like "1h30m" into a Duration while catching every malformed or overflowing input.

Explained by highlit

Intermediate parsing error-handling checked-arithmetic state-machine enums

1use std::time::Duration;
2 
3#[derive(Debug, PartialEq)]
4pub enum ParseDurationError {
  Empty,
  UnexpectedChar(char),
  MissingUnit,
  Overflow,
9}
10 
11pub fn parse_duration(input: &str) -> Result<Duration, ParseDurationError> {
  let input = input.trim();
  if input.is_empty() {
      return Err(ParseDurationError::Empty);
  }
16 
  let mut total_secs: u64 = 0;
  let mut current: u64 = 0;
  let mut has_digits = false;
20 
  for ch in input.chars() {
      match ch {
          '0'..='9' => {
              current = current
                  .checked_mul(10)
                  .and_then(|v| v.checked_add((ch as u8 - b'0') as u64))
                  .ok_or(ParseDurationError::Overflow)?;
              has_digits = true;
          }
          _ => {
              if !has_digits {
                  return Err(ParseDurationError::UnexpectedChar(ch));
              }
              let multiplier = match ch {
                  'd' => 86_400,
                  'h' => 3_600,
                  'm' => 60,
                  's' => 1,
                  other => return Err(ParseDurationError::UnexpectedChar(other)),
              };
              let segment = current
                  .checked_mul(multiplier)
                  .ok_or(ParseDurationError::Overflow)?;
              total_secs = total_secs
                  .checked_add(segment)
                  .ok_or(ParseDurationError::Overflow)?;
              current = 0;
              has_digits = false;
          }
      }
  }
52 
  if has_digits {
      return Err(ParseDurationError::MissingUnit);
  }
56 
  Ok(Duration::from_secs(total_secs))
58}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Modeling each failure mode as an enum variant makes error handling exhaustive and self-documenting.
2Checked arithmetic converts silent overflow into an explicit, recoverable error.
3A couple of accumulator variables let you parse in one pass without allocating substrings.

Related explainers

package logparse
 
import (
	"bufio"

Splitting multi-line logs with a Scanner

parsing streaming bufio

Intermediate 9 steps

typescript

type TokenType = "keyword" | "string" | "comment" | "number" | "text";
 
interface Token {
  type: TokenType;

How a regex tokenizer highlights code

tokenizer regex lexing

Intermediate 10 steps

javascript

const express = require('express');
const router = express.Router();
 
router.get('/articles/:slug', async (req, res, next) => {

Conditional GET caching in Express

http-caching conditional-get routing

Intermediate 8 steps

rust

use std::time::Duration;
 
#[derive(Debug, Clone, Copy)]
pub struct LatencyStats {

Computing latency percentiles in Rust

percentiles interpolation closures

Intermediate 6 steps

package handlers
 
import (
	"net/http"

Custom validators and binding in Gin

validation struct-tags error-handling

Intermediate 8 steps

ruby

class ImageNormalizer
  ORIENTATION_TRANSFORMS = {
    1 => ->(img) {},
    2 => ->(img) { img.flop },

Correcting EXIF orientation in Ruby

lookup-table lambdas image-processing

Intermediate 7 steps

Share this explainer

Here's the card — post it anywhere.

Parsing duration strings safely in Rust — share card

Made with highlit — turn any snippet into a walkthrough like this in about a minute.

Explain your code