@skirpichev, 
> I mean, atom.is_Symbol is True anyway...

if line 8 is
```python
for atom in expr.atoms():
```
then ```expr``` would give back all ```atoms``` including ```Symbol```s. Therefore,
```python
atom.is_Symbol
```
is necessary. 
But if that is
```python
for atom in expr.free_symbols:

or

for atom in expr.atoms(Symbol);
```
the ```atom.is_Symbol``` is of course does not make sense. 

**Note 1**

One would think using ```atoms(Symbol)``` is preferred over ```free_symbols```.

```python
In [0]: from sympy.printing.lambdarepr import _find_first_symbol

In [1]: r = Integral(x/2, (x, 0, 2))

In [2]: _find_first_symbol(r)
Out[0]: x

In [3]: r = Integral(x/2, (x, 0, 2))

In [4]: _find_first_symbol(r)
Out[1]: ValueError: expression must contain a Symbol: Integral(x/2, (x, 0, 2))
```

**Note 2**

@asmeurer says few days befor,
> What the heck does this function do? There is no "first symbol"; the order of iteration over atoms is arbitrary. We should delete this function .

Yes indeed. for an example,
```python
p = Piecewise((x*y, Interval(0, 1, False, True).contains(y)))
l = lambdarepr(p)
```
should be failed unless below **Note3** happens.

**Note 3**

Most interestingly the function ```_find_first_symbol``` is used only in ```_print_Piecewise``` and it is not of course used by that function too.

Because anything specified as ```Interval``` becomes ```boolean``` type in ```_print_Piecewise``` function.
Consider following code block from ```lambdarepr.py```.
```python
for arg in expr.args:
            e = arg.expr
            c = arg.cond   <-----------(1)
            result.append('((')
            result.append(self._print(e))
            result.append(') if (')
            if isinstance(c, Interval):   <-----------(2)
                result.append(self._print(c.contains(_find_first_symbol(e))))
            else:   <----------(3)
                result.append(self._print(c))
```
The test 
```python
p = Piecewise((x, Interval(0, 1, False, True).contains(x)))
l = lambdarepr(p)
```
gives ```c as And(x < 1, x >= 0)``` (refer line (1)) where the line (2) fails to recognize as an ```Interval``` object. Line (3) does the rest in favor of this function.

**Therefore I decided to remove ```_find_first_symbol``` function from the code repo.**