Consider breaking up primary interfaces, or not exporting them

[toddbaert]

Remove (or unexport) certain identifiers (types, functions, methods, interfaces) that are unnecessary. For example, openfeature.IEvaluation or openfeature.IClient should most definitely not make it into v2. We will want to be especially careful about which interfaces we are exporting. Those that are exported must be named appropriately (not like IClient or ifaceClient or ClientIface).

We need to discuss this further, but we should rethink how we expose these interfaces.

[jblacker]

I think that IEvaluation can be removed completely or at least unexposed. I think instead a client "builder" should be the primary way to set up getting an implementation of IClient. If we don't go the builder route it might be more idiomatic to have an initialization function that implements the option pattern.

On the topic of IClient I also don't think needs to be exported, but instead parts of it should be put into smaller interfaces that can compose an internal IClient, with parts of the smaller interfaces exposed. Won't necessarily be able to remove many of the methods until v2, but it could be a good exercise in moving in the right direction.

iClient interface { // internal (need a better name)
  Metadata() ClientMetadata
  SetEvaluationContext(evalCtx EvaluationContext) // May not be needed
  EvaluationContext() EvaluationContext    // May not be needed
  Evaluator
  detailEvaluator
}

FlagType interface { // exported
  int64 | float64 | string | bool | comparable
}

Client interface { //exported
  Evaluator
  DetailEvaluator
}

Evaluator interface { // exported
  Boolean(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options ...Option) bool
  String(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options ...Option) string
  Float(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options ...Option) float64
  Int(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options ...Option) int64
  Object[T FlagType](ctx context.Context, flag string, defaultValue any, evalCtx EvaluationContext, options ...Option) T
}

DetailEvaluator interface { // exported
  BooleanValueDetails(ctx context.Context, flag string, defaultValue bool, evalCtx EvaluationContext, options ...Option) (BooleanEvaluationDetails, error)
  StringValueDetails(ctx context.Context, flag string, defaultValue string, evalCtx EvaluationContext, options ...Option) (StringEvaluationDetails, error)
  FloatValueDetails(ctx context.Context, flag string, defaultValue float64, evalCtx EvaluationContext, options ...Option) (FloatEvaluationDetails, error)
  IntValueDetails(ctx context.Context, flag string, defaultValue int64, evalCtx EvaluationContext, options ...Option) (IntEvaluationDetails, error)
  ObjectValueDetails[T FlagType](ctx context.Context, flag string, defaultValue any, evalCtx EvaluationContext, options ...Option) (InterfaceEvaluationDetails[T], error)
}

The Evaluator & DetailEvaluator interface in my sample would be helpful to export since those are the important and primarily used methods on the client, whereas everything else is primarily used internally. Client just wraps them together with a nice name for the generated client that leverages the providers.

Curious on other's thoughts about this.