## Rework the RULES story for `elem`.

The old `elem`

rule was

```
"elem/build" forall x (g :: forall b . Eq a => (a -> b -> b) -> b -> b)
. elem x (build g) = g (\ y r -> (x == y) || r) False
```

This rule will ALMOST NEVER FIRE. The argument g of build g has type forall b. (a->b->b) -> b -> b. But the rule asks the rule-matcher to produce a g with that overloaded type. So it compiles to:

```
"elem/build"
forall (@ a)
($dEq :: Eq a)
($dEq1 :: Eq a)
(x :: a)
(g :: forall b. Eq a => (a -> b -> b) -> b -> b).
myelem @ a $dEq x (build @ a (\ (@ b) -> g @ b $dEq1))
= g @ Bool
$dEq
(\ (y :: a) (r :: Bool) -> || (== @ a $dEq x y) r)
False
```

Whereas the right rule, as pointed out by Oleg should be:

```
{-# RULES
"elem/build2" forall x (g :: forall b . (a -> b -> b) -> b -> b)
. elem x (build g) = g (\ y r -> (x == y) || r) False
#-}
```

which compiles to:

```
"elem/build2"
forall (@ a)
($dEq :: Eq a)
(x :: a)
(g :: forall b. (a -> b -> b) -> b -> b).
myelem @ a $dEq x (build @ a g)
= g @ Bool (\ (y :: a) (r :: Bool) -> || (== @ a $dEq x y) r) False
```

That is simpler, faster to match, and (crucially) applies much more often!

Thanks @phadej for spotting this.

However there is trouble! For strings this leads to suboptimal code:

```
= \ (c_aA5 :: Char) ->
unpackFoldrCString#
@Bool
"abcdefh"#
(\ (y_a1ln :: Char) (r_a1lo :: Bool) -> case eqChar c_aA5 ... ) -- Too late, already allocated
GHC.Types.False
```

We sidestep this by adding a built in rule which transforms patterns like `x `elem` "abc"`

into case statements which fires before the elem fusion rule.