Enum Strict 

pub enum Strict {}

The same as Unicode, except that it disallows Mc, Me, and Mn characters at the start of a chunk.

The Issue With Mc, Me, and Mn Characters

If you allow joining characters at chunk-start, you can create some surprisingly valid identifiers.

assert!(LowerCamelIdent::new("_A").is_err()); // Doesn't work (expected).
assert!(LowerCamelIdent::new("_゙A").is_ok());  // Works?
assert!(UpperCamelIdent::new("_a").is_err()); // Doesn't work (expected).
assert!(UpperCamelIdent::new("_゙a").is_ok());  // Works?

If you’re okay with another dependency and slightly less optimized code, you can protect against this with the Strict profile:

assert!(LowerCamelIdent::new("_A").is_err()); // Doesn't work (expected).
assert!(LowerCamelIdent::new("_゙A").is_err()); // Also doesn't work!
assert!(UpperCamelIdent::new("_a").is_err()); // Doesn't work (expected).
assert!(UpperCamelIdent::new("_゙a").is_err()); // Also doesn't work!

When To Use Strict vs. Unicode

You should almost always just use Unicode.

You only want Strict if you really want to enforce that upper and lower camel look a certain way (e.g. that the first character is upper or lower compatible).

Strict processing is a bit slower, and causes the profile to no longer be APPEND_CLOSED for fragments (which reduces the optimizations we can do). It costs you something, and usually it’s not worth the cost.

Trait Implementations

impl CharProfile for Strict

impl Profile for Strict

const APPEND_CLOSED: AppendClosed = AppendClosed::Chunk

Whether or not a fragment containing characters in this profile are append-closed.

type BaseProfile = Strict

The underlying profile that this profile is based on.

type Segmentation = Grapheme

The segmentation strategy that this profile uses.

fn is_ident_start(c: char) -> bool

Whether or not the provided character can appear at the absolute start of an identifier.

fn is_chunk_start(c: char) -> bool

Whether or not the provided character can appear at the start of a new chunk (e.g. right after a delimiter).

fn in_profile(c: char) -> bool

Whether or not the provided character can appear at any point in a chunk.

fn is_chunk_continue(c: char) -> bool

Whether or not the provided character is valid at any position after the first character of a chunk (a run of non-delimiter characters).

impl SubsetOf<Strict> for Ascii

Proof: ASCII is a subset of the Strict profile (which is basically Unicode).

impl SubsetOf<Strict> for Strict

Proof: It’s always safe to implement this against yourself.

impl SubsetOf<Unicode> for Strict

Proof: Strict is a subset of the Unicode profile (strict has more restrictions).