[Question]
  [
I got the following question at a test:
> 
> Write a function `f` with the following type `a -> b -> (a -> b)`. `a` and `b` should not be bound in any sense, the shorter the code, the better.
> 
> 
> 
I came up with `f a b = \x -> snd ([a,x],b)`. Can you find something tinier?
**Currently the winner is: `f _=(.f).const`**
  
[Answer]
Your example can be shrunk by getting rid of the anonymous function on the right-hand side:
```
f a b x = snd ([a,x],b)
```
This works because the type `a -> b -> a -> b` is equivalent to `a -> b -> (a -> b)` in Haskell.
[Answer]
The function `f _=(.f).const` is actually of a more general type than `f :: a -> b -> (a -> b)`, namely `f :: a -> b -> (c -> b)`. If no type signature is given, the type inference system infers a type of `f :: a -> b -> (a -> b)`, but if you include the type signature `f :: a -> b -> (c -> b)` with the exact same definition, Haskell will compile it without issue and will report consistent types for the partial applications of f. There is probably some deep reason why the type inference system is stricter than the type checking system in this case, but I don't understand enough category theory to come up with a reason as to why this should be the case. If you are unconvinced, you are welcome to try it yourself.
[Answer]
Given `ScopedTypeVariables`, I came up with this:
```
f (_::a) b (_::a) = b
```
If you shrink down both my function and yours, mine is a hair shorter:
```
f(_::a)b(_::a)=b
f a b x=snd([a,x],b)
```
Of course, you're probably not allowed to rely on `ScopedTypeVariables` :P.
]