[shape_infer] Can we use explicit(full) template specialization for shape_infer() on static/partial shapes?

[usstq]

Generally we use a generic template code for shape_infer(), since StaticShape & PartialShape and StaticDimension & Dimension both support a common subset of API like: is_static()/is_dynamic()/rank()/compatible()/same_scheme()/refines()/merge_rank()/..., but they also has some differences:

1. for some method that not available in StaticShape/StaticDimension, a single piece of genetic code cannot pass the compilation

	StaticShape	PartailShape
default constructor	NA	scalar
static creater ::dynamic()	NA	return a dynamic rank shape

	StaticDimension	Dimension
constructor take 2 inputs	NA	yes, as lower, upper bound
static creater ::dynamic()	NA	return a dynamic dimension
get_interval()	NA	return the interval of dimension

2. By default, shape_infer can always return PartailShape::dynamic() when it cannot get enough information to infer exact shape, but for StaticShape, we must throw exception.

So my question is, can we use explicit(full) template specialization for shape_infer()?

template
void shape_infer(){
// handle static shape case
}

template <>
void shape_infer(){
// handle partial shape case
}

[jane-intel]

I would suggest to try minimize specialized code

Say, we have three specific lines of code for PartialShape and for StaticShape we should raise an exception there -- then lets create template helper function
template
helper (const T& in, T& out) {
// code for StaticShape
}

template <>
helperov::PartialShape(const ov::PartialShape& in, ov::PartialShape& out) {
// code specific to PartialShape
}

[usstq]

Agree! I have re-factored my code based on this suggest!.

for example,

In shape_infer(), one branch specially designed to handle dynamic shape called a Dimension's member function get_interval() that StaticDimension doesn't implement:

 ...
 auto interval = input_shape[0].get_interval()
 ...

we can re-factor it as

template <typename T>
Interval get_interval(Op* op, T& dim) {
    NODE_VALIDATION_CHECK(op, false, "Cannot get_interval for static shape.");
    return Interval();
}

template <>
Interval get_interval<Dimension>(Op* op, Dimension& dim) {
    return dim.get_interval();
}

 ...
 auto interval = get_interval(op, input_shape[0])
 ...

You can see the generic version of get_interval() through exception since this piece of code shouldn't be called at run-time, but it still returned a default constructed Interval object to pass the compilation.

@jane-intel
But this brings another question, why not add above generic version of get_interval() into StaticDimension as a member function? so that we don't need to introduce the additional helper template ?

class StaticDimension  {
  ....
  Interval get_interval(T& dim) {
      NGRAPH_CHECK( false, "Cannot get_interval for static shape.");
      return Interval();
  }
  ....
};

 ...
 auto interval = input_shape[0].get_interval()
 ...

since shape_infer() is a single piece of generic code that handles both dynamic & static cases with run-time if/else branches, so that the branch handles dynamic case won't be called on static shape at run-time, but we still need them to be syntax correct to pass compile-time checks, then why not align all APIs used by shape_infer() between StaticShape/ParialShape/StaticDimension/Dimension, so all compile-time issue will gone automatically once for all?