Golang：如何实现传递方法/功能

Question

I've the following domain. How do we implement the Transfer functionality that can transfer an amount from one account to another account. I should be able be transfer from a savings to checking and vice versa. I OOP world, a super type makes it easier. I am wondering how we accomplish this in Go.

type AccountData struct {
    Num      string
    Name     string
    OpenDate time.Time
    Balance  float64
}

type SavingsAccount struct {
    InterestRate float32
    AccountData
}

type CheckingAccount struct {
    TransactionFee float32
    AccountData
}

type Account interface {
    Deposit(amount float64) error
    Withdraw(amount float64) error
}

//constructor functions
func OpenSavingsAccount(no string, name string, openingDate time.Time) SavingsAccount {
    return SavingsAccount{
        AccountData: AccountData{Num: no,
            Name:     name,
            OpenDate: openingDate,
        },
        InterestRate: 0.9,
    }
}

func OpenCheckingAccount(no string, name string, openingDate time.Time) CheckingAccount {
    return CheckingAccount{
        AccountData: AccountData{Num: no,
            Name:     name,
            OpenDate: openingDate,
        },
        TransactionFee: 0.15,
    }
}

//Account methods
func (acct *SavingsAccount) Withdraw(amount float64) error {
    if acct.Balance < amount {
        return errors.New("Not enough money to withdraw")
    }
    acct.Balance = acct.Balance - amount
    return nil
}


func (acct *SavingsAccount) Deposit(amount float64) error {
    fmt.Printf("Depositing %f 
", amount)
    acct.Balance = acct.Balance + amount
    return nil
}
func (acct *CheckingAccount) Deposit(amount float64) error {
    fmt.Printf("Depositing %f 
", amount)
    acct.Balance = acct.Balance + amount
    return nil
}
func (acct *CheckingAccount) Withdraw(amount float64) error {
    if acct.Balance < amount {
        return errors.New("Not enough money to withdraw")
    }
    acct.Balance = acct.Balance - amount
    return nil
}

Answer 1

func Transfer(to, from Account, amount float64) error {
    if err := from.Withdraw(amount); err != nil {
        return err
    }
    if err := to.Deposit(amount); err != nil {
        if err := from.Deposit(amount); err != nil {
            // `from` should be alerted that their money
            // just vanished into thin air
        }
        return err
    }
    return nil
}

As an exercise, it might be worthwhile to design an interface in which transactions are atomic.