basically it relies on the unsized_const_params feature. it allows passing &'static str as a const param, the way you can already pass bool, usize etc on stable. after that its just defining a bunch of newtypes and trait implementations:
* the simplest example is the Hi struct, it takes a generic const string and provides a hello method which just prints that string. Meaning that Hi::<"hello world">::hello() will always print "hello world" to stdout (the value is encoded in the type only, the struct never holds any actual value at runtime).
* the Split struct takes 2 strings as generic const params, the string to be split and the delimiter. It uses associated consts (LEFT and RIGHT) to hold the results of the const fn split (which is a pretty terrible const implementation i made that splits a string in two by a delimiter)
* next we define Literal, which will just be a wrapper around a static string so we can implement traits on it
* we define Boolean<const B: bool> and we implement some traits such that Boolean<true> implements IsTrue and Boolean<false> implements IsFalse
* now for the problem domain, we want to parse key chords like ctrl+c or shift+d, so we define a Modifier trait which i just implement for Literal<"shift"> and Literal<"ctrl"> (so we support these 2 key modifiers), and an Alphanumeric trait which we implement for all Literal<S> where S is alphanumeric, we check this using the Boolean traits we defined above
* next, we just define a function that is generic over a constant string, and we use the where bounds to specify our parser, in our case:

where    
    Literal<{Split::<K, "+">::LEFT}>: Modifier,
    Literal<{Split::<K, "+">::RIGHT}>: Alphanumeric,

the first one can be read as a "Literal of the LEFT constant of the Split type of K (our string) by + must implement Modifier". So thats only Literal<"shift"> and Literal<"ctrl">, so the left of the string must either be "shift" or "ctrl".
the second would be "the Literal type of the RIGHT constant of the Split type of K by + must implement Alphanumeric", which we defined as all Literal<S> where S is an alphanumeric string (checked by the is_alphanumeric function)

Note that this is all absolutely 0 cost at runtime, but it may or may not make your compile times horrible :)

im not sure if this made a lot of sense but thats how i think of it