I’d say, generally-speaking, there are two strategies for this:

####
Strategy 1

Either you’d need to declare the units with names for the parts, and declare parts of them optional, as in:

“`A monetary value is a kind of value. $1.99 specifies a monetary value with parts dollars and cents (optional, preamble optional)`

.”

Then “$3” “will be the preferred form when Inform prints out a monetary value which is an exact number of dollars”, see chapter 15.15. The parts of a number specification.

But this doesn’t work so well in a scientific context / in our use case, because Inform would then expect that such numbers exactly conform to the specification regarding the number of digits. For example, if we defined “`1.99C specifies a temperature with parts degrees and subdegrees (optional, preamble optional)`

”, Inform would later throw the error “`you use the notation '8.575C' to write a constant value. But the notation was specified as '1.99C', which means that the second numerical part should range between 0 and 99`

”.

####
Strategy 2

So, I think we are left with the second strategy, which is to print the rounded value and append the unit name explicitly, as you already mentioned in your original post. We could do this, for example, in these different ways:

#####
2.1 For each kind of value:

```
To say rounded (T - a temperature):
let temp-as-num be T divided by 1 degree Centigrade to the nearest whole number;
say "[temp-as-num]C".
To say rounded (M - a mass):
let mass-as-num be M divided by 1kg to the nearest whole number;
say "[mass-as-num]kg".
```

And then:

```
When play begins:
let temp be 8.575 degrees Celsius;
say "temp is [rounded temp].";
let m1 be 5.678kg;
say "m1 is [rounded m1].";
```

#####
2.2 Alternatively, in a type-generic version:

```
To say rounded (original - an arithmetic value of kind K):
let neutral-element be the unit value of K;
let original-as-real be original divided by neutral-element;
let rounded-number be original-as-real to the nearest whole number;
say "[rounded-number]".
```

But here, since I don’t know whether there’s a way to find out and print just the unit name of any given kind, we don’t say the unit name in our type-generic function. So we need to append it in the calling code:

```
When play begins:
let temp be 8.575 degrees Celsius;
say "temp is [rounded temp]C.";
let m1 be 5.678kg;
say "m1 is [rounded m1]kg.";
```