Make a long type signature Challenge
Find an expression, at most 100 bytes long, with the longest type signature.
Rules

Any statically typed language with type inference is allowed
The type must be non-ambiguous, but otherwise may include types without defined instances. For example Num [a] and Eq [a] are allowed, even without a defined instance
No imports other than the minimum required to compile a program with STDIN/STDOUT
Infinite types are not allowed
If an answer has more than one expression, only one may contribute to the score. For example, although the type signature of composition is (.) :: (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c, having a score of 20, the answer with 25 copies of (.)\n would have a score of 20, not 500
The expression must be, at most, 100 bytes
The score is the number of characters in the type signature, excluding the name of the function and any whitespace. For example, f :: (a -&gt; b) -&gt; a -&gt; b would have a score of 12
The highest score wins!

Examples
Although other languages are allowed, the following examples are in Haskell:
Score: 112
map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map
f :: (a -&gt; b)
 -&gt; [[[[[[[[[[[[[[[[[[[[[[[[[a]]]]]]]]]]]]]]]]]]]]]]]]]
 -&gt; [[[[[[[[[[[[[[[[[[[[[[[[[b]]]]]]]]]]]]]]]]]]]]]]]]]    

Score: 240
(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.)
f :: (b-&gt;c)-&gt;(a-&gt;a1-&gt;a2-&gt;a3-&gt;a4-&gt;a5-&gt;a6-&gt;a7-&gt;a8-&gt;a9-&gt;a10-&gt;a11-&gt;a12-&gt;a13-&gt;a14-&gt;a15-&gt;a16-&gt;a17-&gt;a18-&gt;a19-&gt;a20-&gt;a21-&gt;a22-&gt;a23-&gt;a24-&gt;b)-&gt;a1-&gt;a2-&gt;a3-&gt;a4-&gt;a5-&gt;a6-&gt;a7-&gt;a8-&gt;a9-&gt;a10-&gt;a11-&gt;a12-&gt;a13-&gt;a14-&gt;a15-&gt;a16-&gt;a17-&gt;a18-&gt;a19-&gt;a20-&gt;a21-&gt;a22-&gt;a23-&gt;a24-&gt;c

Score: 313
foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl(.)
f :: (Foldable t, Foldable t1, Foldable t2, Foldable t3, Foldable t4,
  Foldable t5, Foldable t6, Foldable t7, Foldable t8, Foldable t9,
  Foldable t10, Foldable t11, Foldable t12, Foldable t13,
  Foldable t14, Foldable t15) =&gt;
 (b -&gt; c)
 -&gt; t (t1 (t2 (t3 (t4 (t5 (t6 (t7 (t8 (t9 (t10 (t11 (t12 (t13 (t14 (t15 (b
 -&gt; b))))))))))))))))
 -&gt; b
 -&gt; c

Score: 538
lex.show.foldl1.mapM.traverse.sum.mapM.sum.traverse.(.).mapM.scanl.zipWith3((.traverse).(.traverse))
 (Num
    (a -&gt; ([[c]] -&gt; t3 [[a1 -&gt; f b]]) -&gt; [[c]] -&gt; t3 [[a1 -&gt; f b]]),
  Num
    (([[c]] -&gt; t3 [[a1 -&gt; f b]])
     -&gt; t1 (t2 ([[c]] -&gt; t3 [[a1 -&gt; f b]]))
     -&gt; [[c]]
     -&gt; t3 [[a1 -&gt; f b]]),
  Show
    (t (t1 (t2 ([[c]] -&gt; t3 [[a1 -&gt; f b]])))
     -&gt; t1 (t2 ([[c]] -&gt; t3 [[a1 -&gt; f b]]))),
  Applicative f, Foldable t,
  Foldable ((-&gt;) (t1 (t2 ([[c]] -&gt; t3 [[a1 -&gt; f b]])) -&gt; a)),
  Foldable
    ((-&gt;) (([[c]] -&gt; t3 [[a1 -&gt; f b]]) -&gt; a -&gt; t3 [a1 -&gt; f b])),
  Traversable t1, Traversable t2, Traversable t3, Traversable t4,
  Traversable t5,
  Traversable ((-&gt;) (t1 (t2 ([[c]] -&gt; t3 [[a1 -&gt; f b]])))),
  Traversable ((-&gt;) ([[c]] -&gt; t3 [[a1 -&gt; f b]]))) =&gt;
 [(t5 (t4 a1) -&gt; f (t5 (t4 b))) -&gt; c -&gt; a1 -&gt; f b]
 -&gt; [(String, String)]
Haskell, ~2^(2^18)
f x=(x,x)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l.l
n=m.m.m.m
n.n.n.n$0

Each application of f roughly double the type signature by transforming the type signature T to (T,T). For example, the fourfold composition f.f.f.f$0 has type
Num a =&gt; ((((a, a), (a, a)), ((a, a), (a, a))), (((a, a), (a, a)), ((a, a), (a, a))))

Each line quadraples the number of applications of f, giving 4^9 = 2^18 at the end. So, the type signature has size of the order of 2^(2^18).