G'day raygun,

As ++ikegami has explained, and you have accepted, there is no compatibility composition.

You have asked about modules. There are some available but I can't say whether they are suitable for your purposes (as you haven't explained that part). Here's a couple. If these aren't suitable, search MetaCPAN using terms reflecting your use case.

• HTML::Fraction may do what you want if you're working with HTML.
• Unicode::Fraction will render any vulgar fraction into something that's intended to look like a Unicode fraction: 12345/67890 becomes something like ¹²³⁴⁵/₆₇₈₉₀ (that's just a rough approximation).

"... write my own function to handle these fractions (there are only a dozen or so), ..."

There's actually 18 in total. Three have the codepoints U+00BC - U+00BE and can be found in the PDF Code Chart "C1 Controls and Latin-1 Supplement". The other 15 have the codepoints U+2150 - U+215E and can be found in the PDF Code Chart "Number Forms".

Writing your own function is pretty easy. I wrote one just for the fun of it: I've put it in a spoiler so as not to spoil your fun if you wanted to do this, but do feel free to look and take any code or ideas you want.

#!/usr/bin/env perl

use strict;
use warnings;
use open OUT => qw{:encoding(UTF-8) :std};

use constant VF => {
    1 => {
        2 => 0xbd, 3 => 0x2153, 4 => 0xbc,
        5 => 0x2155, 6 => 0x2159, 7 => 0x2150,
        8 => 0x215b, 9 => 0x2151, 10 => 0x2152,
    },
    2 => { 3 => 0x2154, 5 => 0x2156, },
    3 => { 4 => 0xbe, 5 => 0x2157, 8 => 0x215c, },
    4 => { 5 => 0x2158, },
    5 => { 6 => 0x215a, 8 => 0x215d, },
    7 => { 8 => 0x215e, },
};

my @tests = (
    [1,2], [1,3], [1,4], [1,10], [3,8], [9,10], [qw{x y}]
);

compose_vulgar_fraction(@$_) for @tests;

sub compose_vulgar_fraction {
    my ($num, $denom) = @_;

    my $composed;

    if (exists VF->{$num} and exists VF->{$num}{$denom}) {
        $composed = chr VF->{$num}{$denom};
    }
    else {
        $composed = join '/', $num, $denom;
    }

    printf "%3s/%-3s : %s\n", $num, $denom, $composed;

    return;
}
[download]

  1/2   : ½
  1/3   : ⅓
  1/4   : ¼
  1/10  : ⅒
  3/8   : ⅜
  9/10  : 9/10
  x/y   : x/y

Thanks much, ikegami and Ken, for the additional explanations and ideas. Super helpful!

Expanding on ikegami's explanation of why a "compatibility composition" might be ambiguous: I also see that, for instance, U+2168 ROMAN NUMERAL NINE has a compatibility decomposition into the capital letters "I" and "X," but even if no other Unicode character has that particular decomposition, that certainly doesn't mean that any "I" followed by an "X" represents the roman numeral and should thus be "compatibility composed" into it.

So yes, I see now why the concept is fraught with peril—in general. But a string like "3\N{FRACTION SLASH}8" seems to have an unambiguous meaning that is always equivalent to U+215C VULGAR FRACTION THREE EIGHTHS. So it seems a compatibility_compose_where_it_makes_sense() function could be written. But it would require judgment calls for every possible "compatibility composition," potentially not all of which would be clear-cut, so I can see why no one's rushing to implement it.

The "C" and "D" transformations are inverse of each other, but there's no inverse to "K".

It's a destructive transformation. For example, both the ANGSTROM SIGN (Å) and the LATIN CAPITAL LETTER A WITH RING ABOVE (Å) are independent symbols with distinct meanings, but they have the same KC form and KD form. There's no way to know how to reverse the transformation to restore the original meaning.

One way of thinking about it, in a simplified ASCII world, would be if you lowercased words to do a case comparison:

  chomp( my $name = lc <$fh> );
  
  if ( $name eq 'bob jones' ) {
    die 'rejecting annoying person';
  }
  
  # Now I want to restore $name to its original mixture of upper and l
+ower case
[download]

toby döt ink

Good analogy (though you really want fc instead of lc to perform a case-insensitive comparison).

Sure, I think it's intuitive why lc('Boaty McBoat') is conceptually a "lossy" transformation (in terms of being able to restore the original string).

But NFKC("\N{VULGAR FRACTION THREE EIGHTHS}") is conceptually "lossless": there is only one Unicode character the resultant string "3\N{FRACTION SLASH}8" could be "composed" into.

As I wrote, I get now why NFKC is conceptually lossy in general. But—unlike with lc—some specific decompositions are exceptions.

Right, which is why, on the surface, it's curious that both NFKD and NFKC return decomposed forms. Some illumination is provided in the documentation: NFKD performs "compatibility decomposition," while NFKC performs "compatibility decomposition followed by canonical composition." So apparently what I want is "compatibility composition," which it seems nothing in that module performs. Thus my question amounts to: does anything else in Perl do compatibility composition?

> I think ...

And I think you are just restating the obvious from the OP.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}