code: func NewClient(config db.Configuration) (*Client, error) {
  	once.Do(func() {
  		connectionString := fmt.Sprintf("%s:%d", config.Host, config.Port)
  		opts := []redis.DialOption{
  			redis.DialPassword(config.Password),
  			redis.DialConnectTimeout(time.Duration(config.Timeout) * time.Millisecond),
  		}
  
  		dialFunc := func() (redis.Conn, error) {
  			conn, err := redis.Dial(
  				"tcp", connectionString, opts...,
  			)
  			if err != nil {
  				return nil, fmt.Errorf("Could not dial Redis: %s", err)
  			}
  			return conn, nil
  		}
  
  		currClient = &Client{
  			Pool: &redis.Pool{
  				IdleTimeout: 0,
  				/* The current implementation processes nested structs using concurrent connections.
  				 * With the deepest nesting level being 3, three shall be the number of maximum open
  				 * idle connections in the pool, to allow reuse.
  				 * TODO: Once we have a concurrent benchmark, this should be revisited.
  				 * TODO: Longer term, once the objects are clean of external dependencies, the use
  				 * of another serializer should make this moot.
  				 */
  				MaxIdle: 10,
  				Dial:    dialFunc,
  			},
  		}
  	})
  	return currClient, nil
  }
docs: // Return a pointer to the Redis client