docs: def create(doc=None, error_text=None, exception_handlers=empty.dict, extend=Type, chain=True, auto_instance=True,
             accept_context=False):
      """Creates a new type handler with the specified type-casting handler"""
      extend = extend if type(extend) == type else type(extend)
  
      def new_type_handler(function):
          class NewType(extend):
              __slots__ = ()
              _accept_context = accept_context
  
              if chain and extend != Type:
                  if error_text or exception_handlers:
                      if not accept_context:
                          def __call__(self, value):
                              try:
                                  value = super(NewType, self).__call__(value)
                                  return function(value)
                              except Exception as exception:
                                  for take_exception, rewrite in exception_handlers.items():
                                      if isinstance(exception, take_exception):
                                          if isinstance(rewrite, str):
                                              raise ValueError(rewrite)
                                          else:
                                              raise rewrite(value)
                                  if error_text:
                                      raise ValueError(error_text)
                                  raise exception
                      else:
                          if extend._accept_context:
                              def __call__(self, value, context):
                                  try:
                                      value = super(NewType, self).__call__(value, context)
                                      return function(value, context)
                                  except Exception as exception:
                                      for take_exception, rewrite in exception_handlers.items():
                                          if isinstance(exception, take_exception):
                                              if isinstance(rewrite, str):
                                                  raise ValueError(rewrite)
                                              else:
                                                  raise rewrite(value)
                                      if error_text:
                                          raise ValueError(error_text)
                                      raise exception
                          else:
                              def __call__(self, value, context):
                                  try:
                                      value = super(NewType, self).__call__(value)
                                      return function(value, context)
                                  except Exception as exception:
                                      for take_exception, rewrite in exception_handlers.items():
                                          if isinstance(exception, take_exception):
                                              if isinstance(rewrite, str):
                                                  raise ValueError(rewrite)
                                              else:
                                                  raise rewrite(value)
                                      if error_text:
                                          raise ValueError(error_text)
                                      raise exception
                  else:
                      if not accept_context:
                          def __call__(self, value):
                              value = super(NewType, self).__call__(value)
                              return function(value)
                      else:
                          if extend._accept_context:
                              def __call__(self, value, context):
                                  value = super(NewType, self).__call__(value, context)
                                  return function(value, context)
                          else:
                              def __call__(self, value, context):
                                  value = super(NewType, self).__call__(value)
                                  return function(value, context)
              else:
                  if not accept_context:
                      if error_text or exception_handlers:
                          def __call__(self, value):
                              try:
                                  return function(value)
                              except Exception as exception:
                                  for take_exception, rewrite in exception_handlers.items():
                                      if isinstance(exception, take_exception):
                                          if isinstance(rewrite, str):
                                              raise ValueError(rewrite)
                                          else:
                                              raise rewrite(value)
                                  if error_text:
                                      raise ValueError(error_text)
                                  raise exception
                      else:
                          def __call__(self, value):
                              return function(value)
                  else:
                      if error_text or exception_handlers:
                          def __call__(self, value, context):
                              try:
                                  return function(value, context)
                              except Exception as exception:
                                  for take_exception, rewrite in exception_handlers.items():
                                      if isinstance(exception, take_exception):
                                          if isinstance(rewrite, str):
                                              raise ValueError(rewrite)
                                          else:
                                              raise rewrite(value)
                                  if error_text:
                                      raise ValueError(error_text)
                                  raise exception
                      else:
                          def __call__(self, value, context):
                              return function(value, context)
  
          NewType.__doc__ = function.__doc__ if doc is None else doc
          if auto_instance and not (introspect.arguments(NewType.__init__, -1) or
                                    introspect.takes_kwargs(NewType.__init__) or
                                    introspect.takes_args(NewType.__init__)):
              return NewType()
          return NewType
  
      return new_type_handler