docs: def is_able_to_convert_detailed(self, strict: bool, from_type: Type[Any], to_type: Type[Any]) \
              -> Tuple[bool, bool, bool]:
          """
          Utility method to check if a parser is able to convert a given type to the given type, either in
          * strict mode : provided_type and desired_type must be equal to this converter's from_type and to_type
          respectively (or the to_type does not match but this converter is generic
          * inference mode (non-strict) : provided_type may be a subclass of from_type, and to_type may be a subclass
          of desired_type
  
          If a custom function was provided at construction time, it is called to enable converters to reject some
          conversions based on source and/or dest type provided.
  
          :param strict: a boolean indicating if matching should be in strict mode or not
          :param from_type:
          :param to_type:
          :return: a tuple of 3 booleans : (does match?, strict source match? (None if no match), strict dest match?
          (None if no match))
          """
          # (1) first handle the easy joker+joker case
          if from_type is JOKER and to_type is JOKER:
              return True, None, None
  
          # Don't validate types -- this is called too often at the initial RootParser instance creation time,
          # and this is quite 'internal' so the risk is very low
          #
          # check_var(strict, var_types=bool, var_name='strict')
          # if from_type is not JOKER:
          #     check_var(from_type, var_types=type, var_name='from_type')
          # if to_type is not JOKER:
          #     check_var(to_type, var_types=type, var_name='to_type')
  
          # -- first call custom checker if provided
          if self.is_able_to_convert_func is not None:
              # TODO Maybe one day, rather push the JOKER to the function ? not sure that it will be more explicit..
              if not self.is_able_to_convert_func(strict,
                                                  from_type=None if from_type is JOKER else from_type,
                                                  to_type=None if to_type is JOKER else to_type):
                  return False, None, None
  
          # -- from_type strict match
          if (from_type is JOKER) or (from_type is self.from_type) or is_any_type(from_type):
              # -- check to type strict
              if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):
                  return True, True, True  # strict to_type match
              # -- check to type non-strict
              elif (not strict) and issubclass(self.to_type, to_type):
                  return True, True, False  # approx to_type match
  
          # -- from_type non-strict match
          elif (not strict) and issubclass(from_type, self.from_type):
              # -- check to type strict
              if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):
                  return True, False, True  # exact to_type match
              # -- check to type non-strict
              elif (not strict) and issubclass(self.to_type, to_type):
                  return True, False, False  # approx to_type match
  
          # -- otherwise no match
          return False, None, None