https://github.com/dtolnay/seq-macro

Macro to repeat sequentially indexed copies of a fragment of code
https://github.com/dtolnay/seq-macro

Last synced: about 2 months ago
JSON representation

Macro to repeat sequentially indexed copies of a fragment of code

• Host: GitHub
• URL: https://github.com/dtolnay/seq-macro
• Owner: dtolnay
• License: apache-2.0
• Created: 2018-08-22T21:15:33.000Z (about 6 years ago)
• Default Branch: master
• Last Pushed: 2024-03-26T05:26:48.000Z (6 months ago)
• Last Synced: 2024-05-09T09:38:18.155Z (5 months ago)
• Language: Rust
• Homepage:
• Size: 184 KB
• Stars: 128
• Watchers: 3
• Forks: 4
• Open Issues: 2
• Metadata Files:
  • Readme: README.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE-APACHE

Awesome Lists containing this project

README

        
`seq!`

======

[](https://github.com/dtolnay/seq-macro)

[](https://crates.io/crates/seq-macro)

[](https://docs.rs/seq-macro)

[](https://github.com/dtolnay/seq-macro/actions?query=branch%3Amaster)

A `seq!` macro to repeat a fragment of source code and substitute into each

repetition a sequential numeric counter.

```toml

[dependencies]

seq-macro = "0.3"

```

```rust

use seq_macro::seq;

fn main() {

    let tuple = (1000, 100, 10);

    let mut sum = 0;

    // Expands to:

    //

    //     sum += tuple.0;

    //     sum += tuple.1;

    //     sum += tuple.2;

    //

    // This cannot be written using an ordinary for-loop because elements of

    // a tuple can only be accessed by their integer literal index, not by a

    // variable.

    seq!(N in 0..=2 {

        sum += tuple.N;

    });

    assert_eq!(sum, 1110);

}

```

- If the input tokens contain a section surrounded by `#(` ... `)*` then only

  that part is repeated.

- The numeric counter can be pasted onto the end of some prefix to form

  sequential identifiers.

```rust

use seq_macro::seq;

seq!(N in 64..=127 {

    #[derive(Debug)]

    enum Demo {

        // Expands to Variant64, Variant65, ...

        #(

            Variant~N,

        )*

    }

});

fn main() {

    assert_eq!("Variant99", format!("{:?}", Demo::Variant99));

}

```

- Byte and character ranges are supported: `b'a'..=b'z'`, `'a'..='z'`.

- If the range bounds are written in binary, octal, hex, or with zero padding,

  those features are preserved in any generated tokens.

```rust

use seq_macro::seq;

seq!(P in 0x000..=0x00F {

    // expands to structs Pin000, ..., Pin009, Pin00A, ..., Pin00F

    struct Pin~P;

});

```




#### License



Licensed under either of Apache License, Version

2.0 or MIT license at your option.








Unless you explicitly state otherwise, any contribution intentionally submitted

for inclusion in this crate by you, as defined in the Apache-2.0 license, shall

be dual licensed as above, without any additional terms or conditions.