
	Where results make sense

Topic: Latent typing

Related Topics

XBM

Ramban

Saint Ambrose

Sfakia

Colfax Avenue

Greater London Council

	Type inference - Wikipedia, the free encyclopedia
		Type inference refers to the ability to automatically either partially or fully deduce the type of the value derived from the eventual evaluation of an expression.
		As this process is systematically performed at compile time, the compiler is often able to infer the type of a variable or the type signature of a function, without explicit type annotations having been given.
		The origin of this algorithm is the type inference algorithm for the simply typed lambda calculus, which was devised by Haskell B. Curry and Robert Feys in 1958.
	en.wikipedia.org /wiki/Type_inference (683 words)

	type system terminology
		Static typing is when types are assigned to the elements of a program’s code, such as its variables and expressions.
		Type safety is used to describe an operation or construct that cannot violate the rules of the type system.
		For example, the C type casting operator is not type safe because it allows you to mix totally incompatible types.
	cakoose.com /wiki/type_system_terminology (1776 words)

	Programming language - Wikipedia, the free encyclopedia
		In some languages, the meaningless operation will be detected when the program is compiled ("static" type checking), and rejected by the compiler, while in others, it will be detected when the program is run ("dynamic" type checking), resulting in a runtime exception.
		Dynamic typing, also called latent typing, determines the type-safety of operations at runtime; in other words, types are associated with runtime values rather than textual expressions.
		Type inference in Generic Java—the research language that provided the basis for Java 1.5's bounded parametric polymorphism extensions—is discussed in two informal manuscripts from the Types mailing list: Generic Java type inference is unsound (Alan Jeffrey, 17 Dec 2001) and Sound Generic Java type inference (Martin Odersky, 15 Jan 2002).
	en.wikipedia.org /wiki/Programming_language (3924 words)

	About Latent Typing (Site not responding. Last check: 2007-10-31)
		Latent types are one solution, but not the only one available if Sun is changing the language anyway.
		Latent typing is all goodness unless you're developing in a component-based language.
		I see a lot of argument about whether latent typing is good (or would be good for Java), but very little discussion of another of Bruce's points: the kind of "generics" implemented in Java doesn't actually buy you much over just using interfaces; it appears to be primarily designed to hide casting.
	www.mindview.net /WebLog/wiki-0051 (2737 words)

	[No title]
		But the main thrust of his articles is to talk about latent typing of the variables themselves, as opposed to the types of the objects to which they are referring.
		Latent typing is where a particular expression or variable's type may not be self-evident from the source code.
		, and it is a latent type: its type is not knowable from this source code alone, and is determined by the particular instance of the generic function.
	www.interact-sw.co.uk /iangblog/2004/03/14/generics (1713 words)

	Re: Lambda - let's write it down
		Type errors like trying to add an integer to a string are only detected and signalled during the execution of a program.
		Static typing is also a good thing, but it takes more work to do it well, which is why scripting languages tend to punt on the issue and just go with latent typing.
		Hm, well, "type inference" is another common terminology for implicit/latent typing, and I hardly think people would think of type inferred from the "names", when they hear about inferred types.
	www.codecomments.com /message366939.html (3019 words)

	Oliver Steele » Blog Archive » Test versus Type
		Since the cost/benefit ratio of type declarations can be different at different points in program maturity, one style would be to add them late in program development (for performance reasons, or for their documentation benefits to future maintainers).
		Latent type is a synonym for implicit type.
		Manifest type is a synonym for explicit type.
	osteele.com /archives/2003/08/test-versus-type (2957 words)

	Type Checking and Techie Control
		There are situations where latent typing, sometimes called weak typing, frees up what you're doing so much that you can really think about the problem and the expression becomes clean.
		Latent type checking gives you much more flexibility in your programming.
		The way I describe it to C++ programmers is that with latent typing, or Python in general, when you write a function, you get templates without templates.
	www.artima.com /intv/typing.html (942 words)

	Static Typing Where Possible, Dynamic Typing When Needed \| Lambda the Ultimate
		Afaik, Robert Harper's "thesis that dynamic typing is a particular case of static typing" is merely a way to embed a dynamically-typed program in a statically-typed language, using a data type for tagged values, e.g.
		Latent type information is implicit at the program's terms, and without explicit type annotations or a way to infer types, there's a limit to what can be done.
		The type abstraction property guarantees that there are no welltyped programs that can distinguish different representations of the same type on properties that are part of their specification, provided the representations have the same specification, and if both conform to their specification.
	lambda-the-ultimate.org /node/834 (13727 words)

	Static Types vs. Partially Evaluated Latent Types \| Lambda the Ultimate
		Unfortunately, the informal way you defined latent typing (reject programs where typechecks still occur) is actually, uhm, (a) problematic (how to treat data-types/decidability?) and (b) seems like a form of static typing to me.
		I wasn't trying to define latent typing in that manner, I was merely trying to the term in the sense that Schemers use it.
		Usually, latent typing only catches errors at run-time, but the type checks that happen at run-time seem like they could be evaluated at compile time if we tried hard enough.
	lambda-the-ultimate.org /node/view/795 (980 words)

	Bruce Eckel's MindView, Inc: 3-11-04 About Latent Typing (Site not responding. Last check: 2007-10-31)
		Latent typing is somehow connected to whether the language is static or dynamic.
		However, in C++ the latent type is clearly enforced, and at compile time.
		Latent typing simply takes this one step further, and makes that interface latent so you don't have to express the interface, or to implement it in every class that you want to use in the function.
	mindview.net /WebLog/log-0051 (1753 words)

	Is Weak Typing Strong Enough? (Site not responding. Last check: 2007-10-31)
		Static type systems are rigidly picky, and you have to spend a bunch of time learning their way of modeling the world, plus additional syntax rules for specifying the static types.
		Also, static type errors (aka compiler errors) are especially hard for language learners to figure out, because the poor program hasn't had a chance to run yet.
		And in general, you lose on early warnings of type errors (at least from a compiler), they're harder to optimize for performance, it's harder to do automated static analysis on them, and it can be harder to look at the code and figure out the type of a variable or expression.
	www.cabochon.com /~stevey/blog-rants/strong-weak-typing.html (3966 words)

	[No title]
		There's been lots of talk lately concerning the way that C# type checks method calls when the calling function is compiled, even if the caller is a generic function.
		The articles that brought the use of the term "latent typing" into vogue in this particular context were these ones by Bruce Eckel.
		All latent typing means is that a given variable's type is not defined explcitly, but it is known and has an impact nonetheless.
	www.interact-sw.co.uk /iangblog/2005/01/06/notlatent (2285 words)

	Latent Typing - Guile Reference Manual (Site not responding. Last check: 2007-10-31)
		In the same vein, there is no way to declare the expected type of a procedure's return value.
		Instead, the types of variables and expressions are only known – in general – at run time.
		But equally, it can be perfectly valid for two separate invocations of the same procedure to specify arguments with different types, and to return values with different types.
	www.gnu.org /software/guile/docs/docs-1.8/guile-ref/Latent-Typing.html (305 words)

	A novel approach to obtaining reliable PCR results from luminol treated bloodstains
		In this study, several dilutions of latent bloodstains were prepared in an effort to simulate transferred bloodstains that are routinely encountered in a crime scene setting.
		The latent bloodstains were treated with luminol and subsequently collected using conventional cotton tipped swabs as well as a Puritan™ sponge tipped swab.
		PCR typing at the Promega GenePrint® PowerPlex™ 1.1 loci was then attempted upon all dilutions of the latent bloodstains for both collection mediums.
	www.astm.org /JOURNALS/FORENSIC/PAGES/3476.htm (371 words)

	Interfaces: Signatures and Semantics (Site not responding. Last check: 2007-10-31)
		Thinking a little about latent interfaces (and latent typing, but mostly the interfaces) -- one of the issues with an interface in Python (or this Smalltalk implementation that someone noted in a comment) is that they consist of method signatures, but nothing about semantics.
		This is even more true with latent interfaces (where latent interfaces are the interfaces you can infer from how code uses an object).
		The way to make latent interfaces safer in a dynamic environment is generally to choose good method names -- you shouldn't use the same method name for two conceptually different operations.
	blog.ianbicking.org /interfaces-signatures-and-semantics.html (572 words)

	Thinking in Generics
		There is extra typing of course (in the combinatino of dynamic and static typing sense, and in the tap-tap-tap of the keys sense), which makes it not as fun to write, but it shines in people being able to read the code, make sense of it, and change it.
		He then argues that latent typing is another useful loosening of constraints, and that this latent typing is what gives you the power of generics.
		So he thinks that latent typing is a way that you can rework the constraints only slightly, and in doing so enable programmers to express simply things that can otherwise only be expressed in complex ways.
	www.theserverside.com /news/thread.tss?thread_id=24445 (5935 words)

	Bruce Eckel on "Latent Typing"
		It's worth noting that one of the things that helped push Bruce over to the latent typing side was unit tests.
		I've been giving a lot of thought to that and I realized that one of the benefits of strong typing is that it is a form of testing.
		Specifying types in signatures (for example) makes this type of bug more unlikely in strongly typed languages.
	use.perl.org /comments.pl?sid=23190&cid=35468 (194 words)

	Guile Reference Manual: Basic Ideas
		Compound types, which allow a group of primitive and compound values to be stored together, include lists, pairs, vectors and multi-dimensional arrays.
		The "type" of a variable -- insofar as the idea is meaningful at all -- is simply the type of whatever value the variable happens to be storing at a particular moment.
		For any data type which can be expressed literally like this, the syntax of the literal data expression for that data type -- in other words, what you need to write in your code to indicate a literal value of that type -- is known as the data type's read syntax.
	www.seul.org /~grumbel/tmp/guile-1.6.0/guile_15.html (5790 words)

	CCI References and Links
		- (Slideshow) This study examined the likelyhood of recovering useable latent prints or DNA from fired cartridge cases and unfired cartridges.
		DOJ's Latent Print Section and CCI evaluated the effects of common Latent Print processing materials and procedures on the ability to successfully type biological samples.
		The feasibility of obtaining body fluid Identification and DNA typing results from samples 'aged' in various environments was studied.
	www.cci.ca.gov /Reference/resources.htm (163 words)

	Latent Types Smell
		Java's strict adherence to explicit types means that such a mess cannot happen, because the passed object type is always stated in the definition of the method (the equivalent of C++'s procedure in this example).
		Yet Chris is correct that latent typing has its set of problems, and he is correct to point out that Bruce's plea for latent typing in Java generics is misguided as it was a conscious design decision on the part of Java designers not to include latent typing.
		Whatever problems latent typing solves are solve more elegantly and without giving up on good SoftwareEngineering practices in languages like ML or Haskell, so latent typing is not a necessity but a convenience for C++ implementors and an inconvenience to the software engineers making use of it.
	c2.com /cgi/wiki?LatentTypesSmell (2324 words)

	Professional Women Photographers Online - Copyright Information
		Copyright is a right, granted to you by law, to control the copying, reproduction, distribution, derivative use, and public display of your photographs, and to sue for unauthorized use (infringement) of your work.
		Some persons when typing or wordprocessing and some computer programs use a c in parenthesis [(c)] as a substitute for a (C).
		To the best of our knowledge this form of notice has never been rejected by a court, but there is no guarantee that a court would uphold a (c) as proper notice.
	www.pwponline.org /copyright.php (2569 words)

	Otaku, Cedric's weblog: The Perils of Duck Typing
		So his idea is that you could switch between different type systems according to what you do ("classic" types, typestates, type inference....) or even switch them off when you want to do some prototyping.
		Java programmers should note, though, that duck typing allows you do things that are so cumbersome in a statically typed language that you don't consider them plausible in the first place, so you don't consider them when you're doing a language comparison.
		A fairly obvious reconciliation of the two views on duck typing was the attitude of those of us who put forth the (short-lived) "Smalltalk protocol" idea: explicit abstract data types to hold the interface actually used/expected by real callers.
	www.beust.com /weblog/archives/000269.html (3856 words)

	Latent Typing :: DenkzeitWiki
		Something is latent if it is present but not visible.
		So latent typing has usually been used to describe situations where something has a type, but that type is not explicitly called out in the source code.
		latent typing rarely implies exactly what the target type should provide, it merely imposes constraints
	www.gungfu.de /facts/wiki/Main/LatentTyping (162 words)

	Latent interfaces (Site not responding. Last check: 2007-10-31)
		Bruce Eckel uses the term latent interfaces to describe Python (or other dynamic languages') implicit interfaces (if it looks like a duck).
		'Latent Typing' is also the subject of Bruce's keynote at PyCon in a few weeks --
		in this talk I will look at various issues and arguments surrounding the concept of type, and in particular examine the phenomenon of 'latent typing' (often called 'weak typing'), why the concept is powerful, and how it is expressed in different languages.
	blog.ianbicking.org /latent-interfaces.html (175 words)

Try your search on: Qwika (all wikis)