# Overview

Intfprgm helps separate interface from implementation.

Intfprgm offers a set of decorators to clearly mark and enforce a class to be an interface, an abstract class, or a concrete class, and a function to be abstract.

To define an abstract function, we can use abstract decorator:

@abstract
def func():
pass


Or raise NotImplementedError in the very first line:

def func():
raise NotImplementedError()


An interface can be defined with interface decorator:

@interface
class Interface(object):

def method_1(self):
raise NotImplementedError()

@abstract
def method_2(self):
pass


An abstract class is defined with the same abstract decorator:

@abstract
class BaseClass(Interface):

def method_1(self):
pass

# method_2 is inherited from Interface and is still undefined


A concrete class is defined with concrete decorator:

@concrete
class ConcreteClass(BaseClass):

def method_2(self):
pass


When you need to ensure that your derived classes correctly override a method in their bases, you can use overrides decorator. This decorator must be applied on both the derived class, and its overriden methods:

class Base(object):

def to_be_overriden(self):
pass

@overrides
class Derived(Base):

@overrides
def to_be_overriden(self):
pass