Invalid indirect of type func (int) string

Question

I'm getting stucked with the following error:

./main.go:76: invalid indirect of Fizzbuzz (type func(int) string)

I understand that the Fizzbuzz function does not satisfy the writeString. My intuition is telling me that this is probably because I should be using an interface to Fizzbuzz? Can someone please give me some direction on how to execute this? What can I do to make this code Go idiomatic?

// -------------------------------INPUT--------------------------------------

// Your program should read an input file (provided on the command line),
// which contains multiple newline separated lines.
// Each line will contain 3 numbers which are space delimited.
// The first number is first number to divide by ('A' in this example),
// the second number is the second number to divide by ('B' in this example)
// and the third number is where you should count till ('N' in this example).
// You may assume that the input file is formatted correctly and the
// numbers are valid positive integers. E.g.

// 3 5 10
// 2 7 15

// -------------------------------OUTPUT------------------------------------

// Print out the series 1 through N replacing numbers divisible by 'A' by F,
// numbers divisible by 'B' by B and numbers divisible by both as 'FB'.
// Since the input file contains multiple sets of values, your output will
// print out one line per set. Ensure that there are no trailing empty spaces
// on each line you print. E.g.

// 1 2 F 4 B F 7 8 F B
// 1 F 3 F 5 F B F 9 F 11 F 13 FB 15

// ---------------------------PROPOSED SOLUTION-----------------------------

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

func Fizzbuzz(N int) (output string) {
    var (
        A = N%3 == 0
        B = N%5 == 0
    )

    switch {
    case A && B:
        output = "FB"

    case A:
        output = "F"

    case B:
        output = "B"

    default:
        output = fmt.Sprintf("%v", N)

    }
    return
}

func openFile(name string) *os.File {
    file, err := os.Open(name)
    if err != nil {
        log.Fatalf("failed opening %s for writing: %s", name, err)
    }
    return file
}

func Readln(r *bufio.Reader) {
    line, prefix, err := r.ReadLine()
    if err != nil {
        log.Fatalf("failed reading a line: %v", err)
    }
    if prefix {
        log.Printf("Line is too big for buffer, only first %d bytes returned", len(line))
    }
}

func WriteString(w *bufio.Writer) {
    if n, err := w.WriteString(*Fizzbuzz); err != nil {
        log.Fatalf("failed writing string: %s", err)
    } else {
        log.Printf("Wrote string in %d bytes", n)
    }
}

func main() {
    file := openFile(os.Args[1])
    defer file.Close()

    fi := bufio.NewReader(file)
    Readln(fi)

    fo := bufio.NewWriter(file)
    defer fo.Flush()

    WriteString(fo)
}

Go-Playground

Answer 1

* as a unary operator is used to dereference (or "indirect") a pointer. Fizzbuzz is a function, not a pointer. That is why the compiler says:

Invalid indirect of type func (int) string

What you really want to do is call the function: Fizzbuzz()

So line:

if fizzbuzz, err := w.WriteString(*Fizzbuzz); err != nil {

should be:

if fizzbuzz, err := w.WriteString(Fizzbuzz()); err != nil{

---

It is not very idiomatic to call the first return of writestring something like fizzbuzz. Normally we name it "n".

if n, err := w.WriteString(Fizzbuzz()); err != nil{