func (f *Features) AppendProps(dst []interface{}, properties *configProperties) error {
	featuresData := reflect.ValueOf(f.BlueprintEmbed).Elem()
	for _, featureKey := range properties.featureList {
		if properties.features[featureKey] {  
			featureFieldName := featurePropertyName(featureKey)
			featureStruct := featuresData.FieldByName(featureFieldName)
			if !featureStruct.IsValid() {
				panic(fmt.Sprintf("Field returned for property %s isn't valid\n", featureFieldName))
			}
			featureStructPointer := featureStruct.FieldByName("BlueprintEmbed").Interface()
			if featureStructPointer != nil {
				err := AppendMatchingProperties(dst, featureStructPointer)
				if err != nil {
					return err
				}
			}
		}
	}
	return nil
}
AppendProps merges properties from BlueprintEmbed to dst, but only for enabled features
expect that Features are inited (before using this function we should call Features.Init)
expect that properties.Features should contain all available features (whenever disabled/enabled)
package core
import (
	"fmt"
	"reflect"
	"strings"
)
func featurePropertyName(name string) string {
	result := strings.ToLower(name)  
	if len(name) > 0 {
		return strings.ToUpper(name[0:1]) + result[1:]
	}
	return result
}
type Features struct {
	BlueprintEmbed interface{}
}
type singleFeature struct {
	BlueprintEmbed interface{}
}
func typesOf(list ...interface{}) []reflect.Type {
	types := make([]reflect.Type, len(list))
	for i, element := range list {
		types[i] = reflect.TypeOf(element)
	}
	return types
}
func (f *Features) Init(properties *configProperties, list ...interface{}) {
	if len(list) == 0 {
		panic("List can't be empty")
	}
	propsType := coalesceTypes(typesOf(list...)...)
	fields := make([]reflect.StructField, len(properties.featureList))
	for i, featureName := range properties.featureList {
		fields[i] = reflect.StructField{
			Name: featurePropertyName(featureName),
			Type: reflect.TypeOf(singleFeature{}),
		}
	}
	bpFeatureStruct := reflect.StructOf(fields)
	instancePtr := reflect.New(bpFeatureStruct)
	f.BlueprintEmbed = instancePtr.Interface()
	instance := reflect.Indirect(instancePtr)
	for i := range properties.featureList {
		propsInFeature := instance.Field(i).Addr().Interface().(*singleFeature)
		propsInFeature.BlueprintEmbed = reflect.New(propsType).Interface()
	}
}
func coalesceTypes(list ...reflect.Type) reflect.Type {
	if len(list) == 0 {
		panic("List can't be empty")
	}
	if len(list) == 1 {
		return list[0]
	}
	fieldsKeys := map[string]bool{}
	fields := []reflect.StructField{}
	for _, elementType := range list {
		for i := 0; i < elementType.NumField(); i++ {
			field := elementType.Field(i)
			fieldName := field.Name
			if _, ok := fieldsKeys[fieldName]; ok {
				panic(fmt.Sprintf("Name collision: '%v'\n", fieldName))
			} else {
				fieldsKeys[fieldName] = true
				fields = append(fields, field)
			}
		}
	}
	return reflect.StructOf(fields)
}