Adding Type Hints to Existing Python Functions

Type hints are a powerful feature in Python that improve code readability, maintainability, and help catch errors early on. This challenge asks you to take a set of existing Python functions (without type hints) and add appropriate type hints to them, ensuring they accurately reflect the expected input and output types. This exercise will solidify your understanding of Python's type hinting system and its benefits.

Problem Description

You are given a set of Python functions. Your task is to modify these functions by adding type hints to their parameters and return values. The goal is to make the code more self-documenting and enable static analysis tools (like MyPy) to verify type correctness. You should use the standard Python type hinting system (e.g., int, str, list, dict, Tuple, Optional, Union, Any). Focus on providing accurate and meaningful type hints. Incorrect or misleading type hints can be worse than no type hints at all.

Examples

Example 1:

def add(x, y):
  return x + y

Modified:

def add(x: int, y: int) -> int:
  return x + y

Explanation: The add function takes two integer arguments and returns an integer. The type hints x: int, y: int, and -> int accurately reflect this.

Example 2:

def greet(name):
  return "Hello, " + name

Modified:

def greet(name: str) -> str:
  return "Hello, " + name

Explanation: The greet function takes a string argument and returns a string. The type hint name: str and -> str specify the expected types.

Example 3:

def process_data(data):
  if data is None:
    return None
  else:
    return len(data)

Modified:

from typing import Optional, List

def process_data(data: Optional[List[int]]) -> Optional[int]:
  if data is None:
    return None
  else:
    return len(data)

Explanation: The process_data function can accept a list of integers or None. The type hints data: Optional[List[int]] and -> Optional[int] reflect this possibility of a None input and return value.

Constraints

• All functions must be modified to include type hints.
• Type hints must be accurate and reflect the intended behavior of the functions.
• Use standard Python type hinting conventions.
• The functions themselves should not be changed functionally, only the type hints added.
• The provided functions will only use built-in Python types and common operations.

Notes

• Consider using Optional[Type] to indicate that a parameter or return value can be None.
• Use List[Type] to indicate a list of a specific type.
• Use Union[Type1, Type2, ...] to indicate that a parameter or return value can be one of several types.
• Use Any as a last resort when the type is truly unknown or irrelevant. Avoid using Any if a more specific type can be determined.
• Run a static type checker (like MyPy) after adding type hints to verify their correctness. This is the best way to ensure your type hints are accurate and helpful.
• The provided functions are intentionally simple to focus on the core concept of adding type hints.