[Question]
  [
Your task is to write some code in Python 2 or 3 such that this expression:
```
(a+b)(c+d) == a*c + b*c + a*d + b*d
```
will evaluate to `True` without raising any exceptions.
To clarify, I will copy your code into a file, then `from` the file `import *`. Then I will type the expression into the console and verify that it is `True`.
This is code-golf, so the answer with the shortest length (in bytes) wins.
  
[Answer]
## ~~54~~ ~~52~~ ~~50~~ ~~49~~ ~~48~~ ~~45~~ 39 bytes
Removed 4 bytes thanks to Dennis.
The latest version is inspired by the "some reason" in xnor's answer.
```
class t(int):__add__=type
a=b=t()
c=d=0
```
[Answer]
## 54 bytes
```
class m(int):__call__=__add__=lambda*x:m()
a=b=c=d=m()
```
Make an object that inherits from `int`, except adding or calling just returns a copy of itself.
Same length:
```
class m(int):__call__=__add__=lambda a,b:a
a=b=c=d=m()
```
I thought `min` or `{}.get` would work in place of `lambda a,b:a`, but for some reason they act only on the second argument.
[Answer]
# ~~81~~ 66 bytes
```
class e:__mul__=lambda*o:0;__add__=lambda*o:lambda x:0
a=b=c=d=e()
```
[Answer]
### 68 bytes
While it cannot really compete with the existing answers, this one actually performs the calculation in question:
```
from sympy.abc import*
type(a+b).__call__=lambda x,y:(x*y).expand()
```
Explanation:
* SymPy is a module for symbolic computations.
* `sympy.abc` contains all single-letter symbols, in particular ones named `a`, `b`, `c`, and `d`.
* `a+b` is an `Add` object, which represents a general sum.
* `type(a+b).__call__= […]` monkey-patches the `Add` class to give it evaluation capabilities, in this case enabling it to work like a multiplication of caller and callee.
* `expand` is necessary to make the expressions actually equal (since SymPy only performs thorough equality checks on demand).
]