6. Parametric Constraints

Your interface definitions, which can later be used as constraints, can accept type parameters as well.

// The store interface represents a store that sells products.
// It takes a type parameter P that represents the type of products the store sells.
type store[P product] interface {
	Sell(P)
}

type product interface {
	Price() float64
	Name() string
}

type book struct {
	title  string
	author string
	price  float64
}

func (b book) Price() float64 {
	return b.price
}

func (b book) Name() string {
	return fmt.Sprintf("%s by %s", b.title, b.author)
}

type toy struct {
	name  string
	price float64
}

func (t toy) Price() float64 {
	return t.price
}

func (t toy) Name() string {
	return t.name
}

// The bookStore struct represents a store that sells books.
type bookStore struct {
	booksSold []book
}

// Sell adds a book to the bookStore's inventory.
func (bs *bookStore) Sell(b book) {
	bs.booksSold = append(bs.booksSold, b)
}

// The toyStore struct represents a store that sells toys.
type toyStore struct {
	toysSold []toy
}

// Sell adds a toy to the toyStore's inventory.
func (ts *toyStore) Sell(t toy) {
	ts.toysSold = append(ts.toysSold, t)
}

// sellProducts takes a store and a slice of products and sells
// each product one by one.
func sellProducts[P product](s store[P], products []P) {
	for _, p := range products {
		s.Sell(p)
	}
}

func main() {
	bs := bookStore{
		booksSold: []book{},
	}

    // By passing in "book" as a type parameter, we can use the sellProducts function to sell books in a bookStore
	sellProducts[book](&bs, []book{
		{
			title:  "The Hobbit",
			author: "J.R.R. Tolkien",
			price:  10.0,
		},
		{
			title:  "The Lord of the Rings",
			author: "J.R.R. Tolkien",
			price:  20.0,
		},
	})
	fmt.Println(bs.booksSold)

    // We can then do the same for toys
	ts := toyStore{
		toysSold: []toy{},
	}
	sellProducts[toy](&ts, []toy{
		{
			name:  "LEGO bricks",
			price: 10.0,
		},
		{
			name:  "Barbie",
			price: 20.0,
		},
	})
	fmt.Println(ts.toysSold)
}

What's Happening Here?

You're creating a generic interface - an interface that has a type parameter.

Look at the Existing Code

The architect already wrote these types:

userBiller

type userBiller struct {
	Plan string
}

func (ub userBiller) Charge(u user) bill {
	amount := 50.0
	if ub.Plan == "enterprise" {
		amount = 100.0
	}
	return bill{Customer: u, Amount: amount}
}

func (ub userBiller) Name() string {
	return fmt.Sprintf("%s user biller", ub.Plan)
}

orgBiller

type orgBiller struct {
	Plan string
}

func (ob orgBiller) Charge(o org) bill {
	amount := 2000.0
	if ob.Plan == "enterprise" {
		amount = 3000.0
	}
	return bill{Customer: o, Amount: amount}
}

func (ob orgBiller) Name() string {
	return fmt.Sprintf("%s org biller", ob.Plan)
}

The Pattern

Notice:

• userBiller has Charge(u user) - takes a user

• orgBiller has Charge(o org) - takes an org

• Both have Name() string

The Solution

You need to create an interface that can represent both of these:

type biller[C customer] interface {
	Charge(C) bill
	Name() string
}

Breaking Down the Solution

type biller[C customer] interface {
            ^  ^^^^^^^^
            |     |
    Type param  Constraint (C must be a customer)

What [C customer] Means

• C is a type parameter

• C must be a customer (either user or org)

The Methods

Charge(C) bill

• Takes a parameter of type C (whatever customer type)

• Returns a bill

Name() string

• Returns a string

How It Works

When C = user:

biller[user] has:
  - Charge(user) bill
  - Name() string

userBiller implements this!

When C = org:

biller[org] has:
  - Charge(org) bill
  - Name() string

orgBiller implements this!

Complete Solution

type biller[C customer] interface {
	Charge(C) bill
	Name() string
}

That's it! Just those 3 lines.

Why This Works

userBiller implements biller[user] because:

• ✓ Has Charge(user) bill method

• ✓ Has Name() string method

orgBiller implements biller[org] because:

• ✓ Has Charge(org) bill method

• ✓ Has Name() string method

Comparison to Store Example

In the lesson example:

type store[P product] interface {
	Sell(P)
}

In your assignment:

type biller[C customer] interface {
	Charge(C) bill
	Name() string
}

Same pattern! The interface has a type parameter and uses it in a method signature.

Visual Understanding

biller[C customer] interface
  ↓
When C = user:
  userBiller implements biller[user]
  
When C = org:
  orgBiller implements biller[org]

Assignment

The chief architect at Textio has decided she wants to implement billing with generics. Specifically, she wants us to create a new biller interface. A biller is an interface that can be used to charge a customer, and it can also report its name.

There are two kinds of billers:

• userBiller (cheaper)

• orgBiller (more expensive)

A customer is either a user or an org. A user will be billed with a userBiller and an org with an orgBiller.

Create the new biller interface. It should have 2 methods:

• Charge

• Name

The good news is that the architect already wrote the userBiller and orgBiller types for us that fulfill this new biller interface. Use the definitions of those types and their methods to figure out how to write the biller interface definition.

package main

import (
	"fmt"
)

type biller[C customer] interface {
	Charge() 
}

// don't edit below this line

type userBiller struct {
	Plan string
}

func (ub userBiller) Charge(u user) bill {
	amount := 50.0
	if ub.Plan == "pro" {
		amount = 100.0
	}
	return bill{
		Customer: u,
		Amount:   amount,
	}
}

func (sb userBiller) Name() string {
	return fmt.Sprintf("%s user biller", sb.Plan)
}

type orgBiller struct {
	Plan string
}

func (ob orgBiller) Name() string {
	return fmt.Sprintf("%s org biller", ob.Plan)
}

func (ob orgBiller) Charge(o org) bill {
	amount := 2000.0
	if ob.Plan == "pro" {
		amount = 3000.0
	}
	return bill{
		Customer: o,
		Amount:   amount,
	}
}

type customer interface {
	GetBillingEmail() string
}

type bill struct {
	Customer customer
	Amount   float64
}

type user struct {
	UserEmail string
}

func (u user) GetBillingEmail() string {
	return u.UserEmail
}

type org struct {
	Admin user
	Name  string
}

func (o org) GetBillingEmail() string {
	return o.Admin.GetBillingEmail()
}

Solution

package main

import (
	"fmt"
)

type biller[C customer] interface {
	Charge(C) bill
	Name() string
}

// don't edit below this line

type userBiller struct {
	Plan string
}

func (ub userBiller) Charge(u user) bill {
	amount := 50.0
	if ub.Plan == "pro" {
		amount = 100.0
	}
	return bill{
		Customer: u,
		Amount:   amount,
	}
}

func (sb userBiller) Name() string {
	return fmt.Sprintf("%s user biller", sb.Plan)
}

type orgBiller struct {
	Plan string
}

func (ob orgBiller) Name() string {
	return fmt.Sprintf("%s org biller", ob.Plan)
}

func (ob orgBiller) Charge(o org) bill {
	amount := 2000.0
	if ob.Plan == "pro" {
		amount = 3000.0
	}
	return bill{
		Customer: o,
		Amount:   amount,
	}
}

type customer interface {
	GetBillingEmail() string
}

type bill struct {
	Customer customer
	Amount   float64
}

type user struct {
	UserEmail string
}

func (u user) GetBillingEmail() string {
	return u.UserEmail
}

type org struct {
	Admin user
	Name  string
}

func (o org) GetBillingEmail() string {
	return o.Admin.GetBillingEmail()
}

1

Start Simple: What Are You Creating?

You're creating an interface (a contract that says "types must have these methods").

2

Step 1: Look at What Already Exists

The code already has userBiller with these methods:

func (ub userBiller) Charge(u user) bill { ... }
func (ub userBiller) Name() string { ... }

And orgBiller with these methods:

func (ob orgBiller) Charge(o org) bill { ... }
func (ob orgBiller) Name() string { ... }

3

Step 2: What Do They Have in Common?

Both have:

• A Charge method

• A Name method

But Charge is different:

• userBiller.Charge takes a user

• orgBiller.Charge takes an org

4

Step 3: How Do We Make ONE Interface for Both?

Use a type parameter so the interface can work with different customer types:

type biller[C customer] interface {
	Charge(C) bill
	Name() string
}