In the last lesson, we migrated our display.Options struct to use unexported fields. This helped prevent bugs where users might accidentally use the fields directly instead of the helper methods that handle defaults like "no flags passed."

To achieve that, we introduced a constructor function:

func NewOptions(bytes, words, lines bool) Options

While this works, it has a major downside: we lose named arguments and rely instead on argument order, which is:

• Hard to read
• Easy to mess up
• Difficult to maintain in tests

---

The Problem in Tests

Let’s say we want to set only showLines in a test. With our current setup, we’d write:

display.NewOptions(false, false, true)

It's unclear what this does without checking the constructor definition. This makes tests harder to grok.

---

Solution: Constructor Argument Struct

We’ll improve this by defining a new struct type for constructor arguments:

type NewOptionsArgs struct {
    ShowBytes bool
    ShowWords bool
    ShowLines bool
}

Then update our constructor to accept this:

func NewOptions(args NewOptionsArgs) Options {
    return Options{
        showBytes: args.ShowBytes,
        showWords: args.ShowWords,
        showLines: args.ShowLines,
    }
}

Now we can initialize it like this:

args := display.NewOptionsArgs{
    ShowWords: true,
}
ops := display.NewOptions(args)

This gives us the readability of named parameters and the encapsulation of private fields.

---

Refactoring: Reduce Duplication

We're currently duplicating the ShowX fields across both Options and NewOptionsArgs. Instead, we can embed the entire NewOptionsArgs struct into Options.

Update Options to hold args:

type Options struct {
    args NewOptionsArgs
}

Then refactor methods like this:

func (o Options) shouldShowWords() bool {
    return o.args.ShowWords || (!o.args.ShowBytes && !o.args.ShowLines)
}

Constructor becomes:

func NewOptions(args NewOptionsArgs) Options {
    return Options{ args: args }
}

Now, adding a new field like ShowSpaces only requires updating NewOptionsArgs.

---

Usage in Main

In main.go:

args := display.NewOptionsArgs{
    ShowWords: *showWords,
    ShowLines: *showLines,
    ShowBytes: *showBytes,
}
ops := display.NewOptions(args)

We retain full readability and don’t expose any internals.

---

Usage in Tests

Update your tests to:

args := display.NewOptionsArgs{
    ShowLines: true,
}
ops := display.NewOptions(args)

Instead of the error-prone:

display.NewOptions(false, false, true)

---

Summary

We now get:

• Named parameters
• Prevented access to internal fields
• Easy refactoring and extension

While we added a small cost of an extra struct, it’s much easier to maintain and reason about.

---

Commit Changes

Let’s commit everything:

git add cmd/main.go display/display.go counter/count_test.go
git commit -m "Use constructor argument struct in display.NewOptions"

✅ Ready to move on to the next lesson.