I originally had a trip planned for this upcoming week, but I’ll have to cancel it and move it to another date.

I suppose the upside is I’ll be able to release this crate next week, instead of having to wait until returning from my trip. I’m going to finish recovering and then sometime early next week I’ll finally publish this thing.

Next week I’ll write a little retrospective too, that’ll be my article for the month.

I’m basically done, just cleaning up testing and documentation at this point.

There’s certainly more that could be done, but I think I want to get a 0.0.1 release out there, that way others can actually see what I’m working on (as opposed to me just talking about it in devlog updates).

I think it’ll release sometime next week - please look forward to it!

The API has been finalized!

I might change around some things (for instance, I’m currently debating if I want to put the syntax module under core), but for the most part it’s complete - just needs more documentation.

It changed a tiny bit from the last time I posted an example, so let’s take another look:

use crate::syntax::{boundary, delimiter, profile};
use crate::{Conversion, Ident, Chunk};

// A lower_snake_case identifier using the Unicode XID profile.
type LowerSnakeIdent = Ident<
    boundary::None,
    delimiter::LowLine,
    profile::Lower<profile::Unicode>,
>;

// Only allows lower_snake identifiers.
let ident = LowerSnakeIdent::new("example_snake")?;
assert!(LowerSnakeIdent::new("example-kebab").is_err());
assert!(LowerSnakeIdent::new("exampleCamel").is_err());

// You can easily extract segments of the identifier.
// Prints:
// * Chunk(Chunk("example"))
// * Delimiter(LowLine)
// * Chunk(Chunk("snake"))
println!("{ident} segments:");
for segment in ident.segments() {
    println!("* {segment:?}");
}

// You can also easily convert to other identifiers.
//
// The type here is `IdentBuf<Grapheme, LowLine, UpperCamel<Unicode>>`,
// but you can test against strings (`PartialEq` works against `&str`).
assert_eq!(ident.to_upper_camel()?, "ExampleSnake");

I don’t feel at liberty to share the main project I’m prototyping, still. But I can give you all a little sneak peek at how testing is done for the typed identifiers crate!

I’m pretty proud of how it works:

• I have some files that dictate certain valid and invalid identifiers.
• At runtime, the data is expanded in a stress integration test.
• Each “test identifier” is visited, and based on the data, we attempt different operations, and validate against the test data.

Here’s an example for what this test data looks like (not actually in YAML format, just shown that way for example):

- name: "CaféPatron"
  kebab: true
  snake: true
  camel: true
  upper_camel: true
  segments:
  - !Chunk "Café"
  - !Boundary Camel
  - !Boundary Hat
  - !Chunk "Patron"

This entry says:

1. There’s a valid identifier that can parse as mixed-case kebab, mixed-case snake, mixed-case camel, or upper-camel.
2. Based on how the identifier is configured to respect chunk boundaries, it may or may not break apart Café from Patron (if CAMEL or HAT boundary options are enabled, specifically).
3. Tests segmentation using all combinations of options, and ensures that they return ["CaféPatron"] or ["Café", "Patron"] as expected.
4. Tests that case conversion works and respects chunk boundaries (e.g., when converting to another case, we have the same number of chunks, though they may now be slightly reformatted).

It also validates some inverse properties. For example, we cannot parse this as LowerSnakeIdent (according to the data), so we will validate that.

I thought this would be an easy and quick crate, and I’ve grossly underestimated how complicated generalized typed identifiers are.

I’m still not done with this, and it’s still not ready to share. But I can show you what it looks like currently (note: crate is the stand-in for the final crate name, which is currently undecided):

use crate::{casing, delimiter, profile, Ident};

// A lower_snake_case identifier using the Unicode XID profile.
type LowerSnakeIdent = Ident<
    casing::Lower,
    delimiter::LowLine,
    profile::Unicode,
>;

// Only allows lower_snake identifiers.
let ident = LowerSnakeIdent::new("example_snake")?;
assert!(LowerSnakeIdent::new("example-kebab").is_err());
assert!(LowerSnakeIdent::new("exampleCamel").is_err());

// You can easily extract segments of the identifier.
// Prints:
// * Word(Word("example"))
// * Delimiter(LowLine)
// * Word(Word("snake"))
println!("{ident} segments:");
for segment in ident.segments() {
    println!("* {segment:?}");
}

// You can also easily convert to other identifiers.
//
// The type here is `IdentBuf<UpperCamel, LowLine, Unicode>`,
// but you can test against strings (`PartialEq` works against `&str`).
assert_eq!(ident.to_upper_camel()?, "ExampleSnake");

It’s taking a bit longer than I’d like to finish this typed identifiers crate, but I’m pretty happy with the direction it’s heading. I know that if I don’t follow this through now, I’ll have trouble following it through in the future.

I will give it another week. It’s not the most exciting project to release, but I’m happy with the direction it’s heading.

This crate is to have typed identifiers that I can work with in Rust, and for easily and safely converting cases. The main thing it does differently from similar libraries is that it actually has types that exist for the various identifier formats (LowerCamelIdentifier, UpperSnakeIdentifier, etc) instead of just having conversion functions.

This is needed for some future projects I have.

I’m changing when I publish the monthly articles - instead of publishing them at the end of the month, I’m going to start publishing them on the first Monday of the month. This is so that the articles don’t intersect with the weekly devlogs, and because I think that most people probably aren’t reading technical articles over the weekend.

This means the next article will be on August 3rd - please look forward to it!

I didn’t want to work on this more, but it’s hard to look at a list of future improvements and not want to work to fix them now. I feel pretty happy with this update, despite not initially wanting to do it!

There’s definitely more to do here, but I’m really getting annoyed with how much time I’m spending on this website. I’m hoping this week will be the last time I have to spend significant effort on it.

I made an invasive change to the devlogs. If you were subscribed to the RSS feed, the old devlogs may register as new again (sorry about that). I’ll try to avoid that in the future, but it felt like a necessary change.

I’m sure I’ll find little bugs here and there - but this website is not where I want to be spending the majority of my time. I’d much rather spend it on actual software project.