Rename Currency to AbstractCurrency.
Expand on the definition of AbstractCurrency.

This design is workable, but it is still not perfect. One problem is
hidden by the missing method definitions of + and * in class
AbstractCurrency. In particular, how should addition be implemented
in this class? It's easy enough to calculate the correct amount of
the new currency as this.amount + that.amount, but how would you
convert the amount into a currency of the right type? You might try
something like:

  def + (that: Currency): Currency = new Currency {
    val amount = this.amount + that.amount
  }

However, this would not compile:

  error: class type required
    def + (that: Currency): Currency = new Currency {
                                           ˆ
One of the restrictions of Scala’s treatment of abstract types is that
you can neither create an instance of an abstract type, nor have an
abstract type as a supertype of another class. So the compiler would
refuse the example code above that attempted to instantiate Currency.
Replace AbstractCurrency with CurrencyZone.

CurrencyZone defines a factory method make(x: Long): Currency for making
a currency, and defines the basic common elements of a currency in a
redefined inner AbstractCurrency class.

CurrencyZone also defines Currency as an abstract type, for individual
CurrencyZone objects to define.
Add an example US CurrencyZone.

Here, US is an object that extends CurrencyZone. It defines a class
Dollar, which is a subclass of AbstractCurrency. So the type of money in
this zone is US.Dollar. The US object also fixes the type Currency to be
an alias for Dollar, and it gives an implementation of the make factory
method to return a dollar amount.

This is a workable design. There are only a few refinements to be added.