Handling shared options

[michaeldcanady]

When I was working on the batch API I "discovered" an idea about shared options.

batch_header.go

type BatchHeaderOption = newInternal.Option[BatchHeaderable]

// BatchHeader implementation of BatchHeaderable
type BatchHeader struct {
	newInternal.BaseModel
}

// NewBatchHeader creates new instance of BatchHeader
func NewBatchHeader(opts ...BatchHeaderOption) (*BatchHeader, error) {       
        // separate out shared options and apply to baseModel
        base_model, err := NewBaseModel()

        defaultHeader := &BatchHeader{
		base_model,
	}

       for _, opt := range opts {
          if err := opt(defaultHeader); err != nil {
              return nil, err
          }
       }

	return defaultHeader, nil
}

base_model.go

type BaseModel struct {
	// backingStoreFactory factory to create backingStore
	backingStoreFactory store.BackingStoreFactory
	// backingStore the store backing the model
	backingStore store.BackingStore
}

func NewBaseModel(opts ...ModelOption) (*BaseModel, error) {
	defaultModel := &BaseModel{
		backingStoreFactory: store.NewInMemoryBackingStore,
		backingStore:        nil,
	}

	for _, opt := range opts {
		if err := opt(defaultModel); err != nil {
			return nil, err
		}
	}

	return defaultModel, nil
}

The ideal would be the options compatible with both are applied to the BaseModel and the remainder are applied only to BatchHeader... but I am unsure how to achieve this