Why worry about type at all?

Perl takes that approach, coercing integers to reals  or strings and changing 
type binding on as as needed basis:

     $foo = +(6/2).".".12;              # 3.12
     print ($foo/10);                   # .312
     print (7/2);                       # 3.5 - perl promotes ints to floats 

One problem with Perl's approach to typing is that reals are represented as 
floating point numbers in hardware and this can result in rounding errors.  
(this example taken from ./Code/test.pl) 
    3.0 equals 3
    0.01 does not equal .01
    0.01 - .01 is 8.67361737988404e-18

Unlike Perl, it is possible to have dynamic strong typing. Dynamic does not
mean that you can change type binding at runtime, nor does it mean that you 
can coerce literals from one type to another. Dynamic means that the first 
assignment of a variable will control that variable's type binding. If there 
is no explicit assignment of a literal, type binding will not occur until 
runtime. Lisp and MIL are both dynamic strongly-typed languages.

This sort of strong but dynamic typing is used by the ML language.  It forces 
the programmer to decide what numeric type will be used:

    x = 3;    // if you really want x to be bound to 3.0 you have to write 3.0

In a dynamic typed language you don't need type declarations (the compiler is 
smart enough to figure out type based on context). But it also means you  will 
get more compile time errors. 

Languages like ML support parametric polymorphism for functions - i.e.,
parameters can change types across function calls. Static semantic checking
for parametric polymorphism involves attempting to unify the types across
parameter lists.