https://github.com/mathematic-inc/unfmt

A compile-time pattern matching library that reverses the interpolation process of `format!`.
https://github.com/mathematic-inc/unfmt

Last synced: about 2 months ago
JSON representation

A compile-time pattern matching library that reverses the interpolation process of `format!`.

• Host: GitHub
• URL: https://github.com/mathematic-inc/unfmt
• Owner: mathematic-inc
• License: apache-2.0
• Created: 2024-02-11T15:42:42.000Z (8 months ago)
• Default Branch: main
• Last Pushed: 2024-05-05T07:18:44.000Z (5 months ago)
• Last Synced: 2024-05-05T10:46:14.490Z (5 months ago)
• Language: Rust
• Size: 90.8 KB
• Stars: 147
• Watchers: 2
• Forks: 2
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE-APACHE

Awesome Lists containing this project

README

        
# unfmt

[![crates.io](https://img.shields.io/crates/v/unfmt?style=flat-square)](https://crates.io/crates/unfmt)

[![license](https://img.shields.io/crates/l/unfmt?style=flat-square)](https://github.com/mathematic-inc/unfmt)

[![ci](https://img.shields.io/github/actions/workflow/status/mathematic-inc/unfmt/ci.yaml?label=ci&style=flat-square)](https://github.com/mathematic-inc/unfmt/actions/workflows/ci.yaml)

[![docs](https://img.shields.io/docsrs/unfmt?style=flat-square)](https://docs.rs/unfmt/latest/unfmt/)

`unfmt` is a compile-time pattern matching library that reverses the

interpolation process of `format!`.

You can think of it as an extremely lightweight regular expression engine

without the runtime pattern-compilation cost.

## Installation

```sh

cargo add -D unfmt

```

## Usage

```rs

let value = "My name is Rho.";

// Unnamed captures are returned as tuples.

assert_eq!(

    unformat!("My {} is {}.", value),

    Some(("name", "Rho"))

);

// You can put indices as well; just make sure ALL captures use indices

// otherwise it's not well defined.

assert_eq!(

    unformat!("My {1} is {0}.", value),

    Some(("Rho", "name"))

);

// You can also name captures using variables, but make sure you check the

// return is not None.

let mut subject = None;

let mut object = None;

assert_eq!(

    unformat!("My {subject} is {object}.", value),

    Some(())

);

assert_eq!((subject, object), (Some("name"), Some("Rho")));

// If you want to ensure the entire string matches, you can add `true` to the end of the macro.

assert_eq!(unformat!("{1} is {0}", value, true), None);

// If a type implements `FromStr`, you can use it as a type argument. This

// is written as `{:Type}`.

assert_eq!(

    unformat!("Listening on {:url::Url}", "Listening on http://localhost:3000"),

    Some((url::Url::from_str("http://localhost:3000").unwrap(),))

);

```

In general, captures are written as `{:}`. Multiple

captures in a row (i.e. `{}{}`) are not supported as they aren't well-defined.

## Limitations

- There is no backtracking.