1. Interface: This defines the public API of the module, specifying what elements are accessible from outside the module. It typically includes:
* Exports: The functions, classes, variables, or other entities that are made available for use in other modules or parts of the program.
* Types: For languages with strong typing, the interface might also include type definitions that are exposed for use outside the module.
* Constants: Constant values that can be accessed from other modules.
2. Implementation: This contains the actual code that implements the logic of the module. It includes:
* Private elements: Functions, classes, and variables that are not intended to be used outside the module. These are usually hidden from external access.
* Logic: The code that carries out the functionality of the module.
* Dependencies: The imports of other modules or libraries that are required for the module's functioning.
Here's an example in Python:
```python
module.py
Interface:
def public_function(x):
return x * 2
class PublicClass:
def __init__(self, value):
self.value = value
Implementation:
def _private_function(x):
return x + 10
... rest of the implementation ...
```
In this example, `public_function` and `PublicClass` are part of the interface, while `_private_function` is part of the implementation.
The concept of modules and their structure can vary slightly between languages, but the fundamental idea of separating the public interface from the private implementation is common across many programming paradigms.