認(rèn)清事物的本質(zhì)-簡(jiǎn)單

原文鏈接：http://www.reddit.com/r/programming/comments/63tnv/bruce_eckel_33104_im_over_it_java/c02qx55

Latent typing is any type system where you do not need to explicitly write the types of variables down in source code. Its opposite is manifest typing, where you do need to explicitly write the types down in source code.

Static typing is a type system where individual expressions in the source code must have types, whether written or inferred by the compiler. Dynamic typing is a type system where run-time values have types (or not, as the case may be), yet program expressions can be any type. (Purists often say that dynamic typing isn't a type system at all, since the academic definition of types are a syntactic property of the code, but that's getting overly pedantic IMNSHO.)

The overlap is in type-inferencing systems. Languages like Haskell and Ocaml are statically-but-latently typed, with the compiler figuring out the types of your variables.

In theory, there's also an overlap on the other side, where types are written in the source code but aren't checked until runtime. Python 3000 has proposed a system like this, and Common Lisp and Dylan do something similar.

Bruce Eckel's actually using "latent typing" wrong in this article; he really means "structural subtyping". Basically, structural subtyping means that objects or expressions are tested for type-compatibility based on their structures (the methods/fields/values they support), while "nominal subtyping" means that objects are tested for compatibility based on explicit subtyping declaration by the programmer (think Java interfaces). Haskell, ML, and most dynamically typed languages are structurally-subtyped, while most industrial languages are nominally-subtyped.

There's also strong vs. weak typing, which has to do with whether the runtime automatically coerces values to different types.

So basically, there are 4 dimensions:

• Static (expressions have types) vs. dynamic (values have types)
• Strong (values cannot be coerced to other types without a cast) vs. weak (the runtime performs a variety of coercions for convenience)
• Latent (no type declarations) vs. manifest (type declarations)
• Nominal (subtyping relations are declared explicitly) vs. structural (subtyping relations are inferred from the operations available on types)

And you can place most languages on one of these 4 axes, though several support multiple forms of typing:

• Ocaml: static, strong, latent, structural typing
• Haskell: static, strong, latent, structural typing, with nominal typing available via newtype and manifest typing through optional type declarations.
• Erlang: dynamic, strong, latent, structural typing
• Scheme: dynamic, strong, latent, structural typing, with nominal typing available in many object systems.
• Common Lisp: dynamic, strong, latent or manifest typing. Same note about structural vs. nominal typing as Scheme, but nominal subtyping is used more often in practice.
• Python & Ruby: dynamic, strong, latent, structural typing. Nominal subtyping is available via isinstance or Ruby equivalent, but good practice frowns upon it.
• PHP: dynamic, weak, latent, nominal or structural typing. Culture is much friendlier to nominal subtyping than Python or Ruby, but it's not required.
• Java & C++: mostly static, strong, manifest, nominal typing. The casts give you a form of weak-typing when necessary, and C++ templates are structurally typed.
• C: static, generally weak, manifest, nominal typing.
• Assembly: dynamic, weak, latent, structural typing.