This will be the last update to typed-ident for a while.

I still want to add spanned identifiers. That’s my most wanted feature, and arguably the main reason that I even developed the crate in the first place. However, I think it would be best to first have a crate that plans on using the feature before continuing to develop it - so that I can dogfood the design a bit locally.

The crate is in a really good place right now though. It may have a few small design or usability issues, but I think it needs to be used a bit to find them.

Next week, I’ll start preparing the next crate I plan on publishing.

This week I spent a bit of time editing and releasing my latest article - I think it went well!

It’s still not perfect, but I hope it’s helpful to some, and it seems to be well-received. I appreciate everyone who read and gave feedback, and I’ll try to make future articles even better!

Other than that, just a lot of clean-up work in typed-ident. Looking at what’s left to do, it’s not as much as I had feared. I think it may be possible that I am able to release v0.0.3 later next week.

No promises though, it’ll realistically be released when ready.

This took almost my entire week, there was a lot to change just to get a table of contents to be able to generate on the site.

Truth be told, I didn’t want to spend forever perfecting my static site generator, so I just do what I need. Because of that, some parts of it are a tiny bit hacky. So when I decide I want a feature like this, I sometimes have to look at the implementation and come to terms with the fact that it needs written properly before I can get what I want.

I have more I would like to do with this website. But I think I’m going to get v0.0.3 of typed-ident released first, then maybe I’ll come back to this and clean it up a bit more.

Of note, the CSS is pretty bad, it needs some attention. But I don’t want to spend time on the CSS until I fix other usability issues on the site. So I’m going to ask for feedback from various webdev communities and see if there’s anything I should improve or change first.

Anyhow, next week please look forward to a new article serving as an introduction to Rust declarative macros! I plan to continue the articles, specifically focusing on macros, until I’ve said all I want to say about them. Next week, I’ll get back to work on typed-ident as well. I’m looking forward to it!

I was hoping this would only take a week, but it turns out that rewriting the markdown parser is a little harder than I originally anticipated.

The new Markdown parser works now, but I haven’t switched the code to using it just yet. It’s a little too soon, and I’d like to spend some more time testing it.

I’ll continue working on it into next week. After I’m done updating this website, I’ll get back to work on typed-ident.

There’s still more to work on before I’ll feel good about moving on from typed-ident, but this is really heading in a nice direction.

I strongly recommend taking a look at the newly-revised documentation. There’s still a few issues, and some things that I caught right after publishing (like always), but I think it’s still a big jump in quality.

In particular, I think the new presets documentation makes understanding the presets a lot easier.

Now it’s time to move on to 0.0.3 work!

typed-ident has been released!!

It’s only alpha, and I’m thankful for that, because just after publishing I noticed an issue.

The details are present in the GitHub issue that I filed, but the TL;DR is that the uncased types don’t enforce a consistent casing. So SnakeIdent doesn’t have to be either upper or lower case, it can be a mixture of cases.

I knew that this was the case, and originally I had convinced myself that it made sense. But now that I have the crate published, I don’t feel that way any longer. So I’m trying to fix it so that there’s a more strict stance on this.

I’ll still provide the mixed-case variants, they just may be named differently.

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.