May 1, 2024 • Mikolaj Gasior

Context

Go language does not allow optional arguments in function, so when writing one we might ask ourselves how to write a function that could be expanded with more inputs in the future, without breaking compatibility. Let’s have a look at the following simple function from imaginary CLI library that creates a command.

func NewCommand(name string, desc string, handler func() int) {
  // Some code
}

The situation is that the function is used in many applications. However, we need to add a new input to it which is a function that is called just before running the command. Let’s called “post validation”. There is no way of doing this without breaking the compatibility, like shown below.

func NewCommand(name string, desc string, handler func() int, onPostValidation func() error) {
  // Some code
}

Therefore, it is crutial to write our API in a way that its configuration can be easily changed. There are at least 2 ways of doing this:

1. passing an input struct
2. using so-called functional options pattern

Passing an input struct

Check the slightly modified code below.

type NewCommandInput struct {
  OnPostValidation func() error
}

func NewCommand(name string, desc string, handler func() int, newCommandInput *NewCommandInput) {
  // Some code
  if newCommandInput != nil {
    // Do something with its values, assign to command object or whatsoever
  }
}

With such solution, there is no worry about breaking compatibility as new configuration can be added to the NewCommandInput struct (assuming the old fields stay unchanged).

This pattern is often found in AWS SDK.

Using functional options pattern

There is another solution to that problem - shown on below code.

type Command struct {
  //
  options commandOptions
}

type commandOptions struct {
  onPostValidation func(c *Cmd) error
}

type commandOption func(opts *commandOptions)

func OnPostValidation(fn func(c *Command) error) commandOption {
  return func(opts *commandOptions) {
    opts.onPostValidation = fn
  }
}

func NewCommand(name string, desc string, handler func() int, opts ...commandOption) {
  command := &Command{
    options: commandOptions{},
  }
  // Some code
  for _, o := range opts {
    o(&(command.options))
  }
}

Here, struct instance of Commands contains a special field that contains the configuration (here called options), which is a separate struct like the previous example. Hence, this is the place where new stuff would get added. However in this pattern, values are modified by calling a function. By looking at the OnPostValidation we can see it takes a reference to commandOptions and modifies its onPostValidation field (look at what the function returns, that is what interests us).

Now, a sample NewCommand call can be as follows.

NewCommand(someName, someDesc, someHandler, OnPostValidation(func(c *Command) error { 
  // Do something
  return nil
}))

Now, every new input could be created the same way and passed as another argument.

NewCommand(someName, someDesc, someHandler, OnPostValidation(func(c *Command) error { 
  // Do something
  return nil
}), IsRequired(), AllowSomething(5))
# with IsRequired() and AllowSomething(int) modifying field(s) in commandOptions struct

See variadic functions for more information on the last argument in the function (the one with three dots).