
	Where results make sense

Topic: Recursive type

	Z Proposal
		The solution bases on the observation that in free type systems, the recursive occurrences of interest during fixpoint-construction are visible in the domain type of the constructor functions.
		Recursive free-types are a tool for describing trees and terms, where the structure of the defined object is replicated at recursion points.
		Mutual Recursion: Because of the possibility of opaque references to other free types in the domain of a constructor, dependencies between free types are not obvious from the syntax.
	uebb.cs.tu-berlin.de /~wg/zstan/freetype-recursion.html (908 words)

	Type system - Wikipedia, the free encyclopedia
		Types usually have associations either with values in memory or with objects such as variables.
		Type systems that allow polymorphism generally do so in order to improve the potential for code re-use: in a language with polymorphism, programmers need only implement a data structure such as a list or a dictionary once, rather than once for each type of element with which they plan to use it.
		A type-checker for a statically typed language must verify that the type of any expression is consistent with the type expected by the context in which that expression appears.
	en.wikipedia.org /wiki/Dynamic_typing (2783 words)

	Encyclopedia :: encyclopedia : Datatype (Site not responding. Last check: 2007-10-20)
		In computer science, a datatype (often simply a type) is a name or label for a set of values and some operations which one can perform on that set of values.
		Duck typing is a humorous way of describing the (dynamic) typing typical of many scripting languages which guess the type of a value.
		An example of the absence of strong typing is a C cast gone wrong; if you cast a value in C, not only is the compiler required to allow the code, but the runtime is expected to allow it as well.
	www.hallencyclopedia.com /Datatype (2464 words)

	Algebraic data type - Wikipedia, the free encyclopedia (Site not responding. Last check: 2007-10-20)
		An algebraic data type is a datatype whose each value is data from other datatypes wrapped in one of the constructors of the datatype.
		In set theory the equivalent of an algebraic data type is a discriminated union - a set whose elements consist of a tag (equivalent to a constructor) and an object of a type corresponding to the tag (equivalent to the constructor arguments).
		If a datatype is recursive, the entire sum of products is wrapped in a recursive type, and each constructor also rolls the datatype into the recursive type.
	en.wikipedia.org /wiki/Algebraic_data_type (537 words)

	3.2.3 Recursive type specifications
		To realize recursion in its most general form, we would need mechanisms to attach a ``label'' to any node in a prototype tree so that we could refer to it by name from other points in the prototype tree.
		By ``lexical scope within the same prototype tree'' we mean that a recursive meta type node packet must have been preceded by a corresponding recursive prototype operator packet within the same prototype tree, and that the ``back reference'' is made to the one which is most closely nested under under lexical scoping rules.
		Using recursive metatype node packets and recursive prototype operator node packets we obtain sufficiently powerful means to realize recursive type specification for most cases without having to introduce a dynamic name space for node labels and prototype nodes.
	www.mathematik.uni-kl.de /~zca/Reports_on_ca/12/paper_html/node13.html (565 words)

	JOT: Journal of Object Technology - The Theory of Classification Part 4: Object Types and Subtyping (Site not responding. Last check: 2007-10-20)
		Likewise, object types are recursive where the type signatures of their methods accept or return objects of the same type [3].
		Since recursion is not built-in as a primitive notion, we must appeal to the fixpoint theorem to construct recursive objects and types [3].
		Note in passing how the type of equal is a function type (arrow type) and that equal accepts an argument having the same self-type, which accounts for Point being a recursive type.
	www.jot.fm /issues/issue_2002_11/column6/column2 (2833 words)

	[No title]
		For the sake of uniformity, all methods are assumed to expect an argument of the trivial type UNIT and method invocation is assumed implicitly to apply the selected method to the sole element of this type.
		This is in order to force the type of super to depend directly on the type of self, reflecting the earlier strategy for typing super during method combination.
		Secondly, a second-order type expression is constructed for super that depends directly on the self-type; we are therefore not forced to quantify over class generators, as in [Harr91].
	www.dcs.shef.ac.uk /~ajhs/classify/thesis/classif5.doc (6037 words)

	Understanding objects and classes (Site not responding. Last check: 2007-10-20)
		Type abbreviations are not required in theory, but they are crucial in practice, both for smooth interaction with the user and for reasonable efficiency of type inference.
		Intuitively, an object type is composed of the row of all visible methods with their types (for closed object types), and optionally ends with a row variable (for open object types).
		Last, an inheritance clause simply combines the type of fields and methods from the parent class with those of current class; it also ensures that the type of self in the parent class and in the current class are compatible.
	pauillac.inria.fr /~remy/cours/appsem/ocaml044.html (2802 words)

	[No title]
		A quotation of this form describes an n-ary type operator {op}, where n is the number of distinct type variables in the types {ty} on the right hand side of the equation.
		This property provides an abstract characterization of the type {op} which is both succinct and complete, in the sense that it completely determines the structure of the values of {op} up to isomorphism.
		Types defined with {define_type} are not introduced into the {TypeBase}, and {define_type} doesn't handle nested or mutual recursion.
	www.cs.utah.edu /~swalton/hol98/help/Docfiles/Define_type.define_type.doc (806 words)

	Re: Type names vs type structure
		But recursive types and labelled sum types must be introduced by datatype declarations.
		Similarly, type theorists have an anonymous notation for recursive types (\mu).
		(3) The existing syntax for recursive datatypes is cumbersome when used to create (recursive type) constructors, as the parameters to the type constructors must be repeated on each occurrence in the definition.
	www.cis.upenn.edu /~bcpierce/types/archives/1997-98/msg00425.html (658 words)

	recursive type Computer Encyclopedia Enterprise Resource Directory Complete Guide to Internet (Site not responding. Last check: 2007-10-20)
		The commonest example is the list type, in {Haskell}: data List a = Nil
		Cons a (List a) which says a list of a's is either an empty list or a {cons cell} containing an 'a' (the "head" of the list) and another list (the "tail").
		Recursion is not allowed in {Miranda} or Haskell {synonym type}s, so the following {Haskell} types are illegal: type Bad = (Int, Bad) type Evil = Bool -> Evil whereas the seeminly equivalent {algebraic data type}s are acceptable: data Good = Pair Int Good data Fine = Fun (Bool->Fine)
	www.jaysir.com /computer-encyclopedia/r/recursive-type-computer-terms.htm (116 words)

	Ocamlnet 2 Reference Manual : Xdr
		Such types are usually written in a notation that is close to the C notation of structured types.
		In "type terms" you can see the components from which the type has been formed, while a "type" is an opaque representation that has been checked and for that some preprocessing has been done.
		A "type system" is a collection of several types that have names and that can refer to previously defined types (i.e.
	ocamlnet.sourceforge.net /manual-2.2/Xdr.html (824 words)

	Variables and Formulas
		The Nuprl formalization of the logic formulas is by a recursive type.
		type abstraction is defined to be the recursive type whose members are a disjoint union of five elements.
		It should be remarked that the recursive type applied to this purpose is exceedingly efficient.
	www.cs.uwyo.edu /~jlc/prop_gloss/node3.html (214 words)

	Recursive Definitions in Type Theory, by Robert L. Constable and N. P. Mendler (Site not responding. Last check: 2007-10-20)
		The type theories we consider are adequate for the foundations of mathematics and computer science.
		Recursive type definitions are important practical ways to organize data, and they express powerful axioms about the termination of procedures.
		The computational requirements of the theory restrict recursive type definitions involving the total function-space constructor ($\rightarrow$) to those with only positive occurrences of the defined type.
	www.nuprl.org /documents/Constable/RecursiveDefinitions.html (172 words)

	SENG 609.03 Object Theory (Winter 98) - Presentation
		A recursive type is equal to its infinite expansion.
		Type inheritance allows the definition F to be modified to define a new type.
		Type inheritance is analogous to subtyping, but is useful for object-oriented programming because inherited objects have inherited types, not subtypes.
	sern.ucalgary.ca /courses/SENG/609.03/W98/lamsh1/subtype.html (1102 words)

	JOT: Journal of Object Technology - The Theory of Classification (Site not responding. Last check: 2007-10-20)
		It arises because the type recursion in Number fixes the signature of the plus method, and this more general type is still retained in Integer, after the union of fields.
		Type downcasting is typically considered a last resort, a dirty trick to be used on occasions when the natural type system doesn't help.
		Working backwards from the desired goal, it seems that our intuitive notion of classification requires a type system in which recursive types can have methods that are closed over their own type, but which are nonetheless related to each other in some systematic way.
	www.jot.fm /issues/issue_2003_05/column2 (3108 words)

	[Nickle]Recursive datatypes (was: Tonight's topics)
		An important distinction is between the runtime type of a value, and the static analysis that ensures that runtime type errors will not occur.
		Note that t_y is not a recursive type: just a nested structure type.
		recursive) values in (new) Nickle, because there is no way to "tie the knot", so you'd have to type an infinitely long initializer in.
	keithp.com /pipermail/nickle/2002-July/000112.html (250 words)

	[No title]
		Recursive types: Last time, we saw that adding recursive functions to the language makes it somewhat difficult to construct logical relations.
		That is, in principle, we can represent expressions as trees and write interp using only a "fold" on those trees.) So to some degree, to really tackle the problems of recursive functions or refs, you really have to tackle the problem of recursive types.
		That is, the type we need for this language is really: datatype D = Fn of D->D Now building a set-theoretic interpetation of this equation is problematic.
	www.eecs.harvard.edu /~greg/cs256sp2005/lec18.txt (509 words)

	ST5
		Mutually recursive ASN.1 types could be modelled by replacing the occurrence(s) of the second type in the first with any, which would in practice always contain a value of the second type.
		Recursion will be treated exactly in the same way it is now for the cases that are currently solved, and will be broken by means of introducing a minimum number of ANYs so that no recursion happens in the remaining recursive cases.
		The only solution to indirect mutual recursion, then, is to loose type safety by introducing an IDL any, and semantically restricting its contents to those of the recursive type (applications are responsible to enforce the semantics).
	www.opengroup.org /external/jidm/st5.htm (783 words)

	[No title]
		The first term gives explictly the values of the function on all constructors for each type for which a function is defined, and the second one uses the variable "allelse" to give the values for some of the constructors.
		If there is a variable "arg" with type TY as one of the subterms of this value (the one to the right of the =), this will be replaced by the constructor applied to arguments (again, (SCONatpat sc)).
		We know that ap must have type atpat (since it's the second arg to constructor CONpat), and so the only recursive function that can be applied to it is varcon_atpat, the function being defined for that type.
	www.cs.utah.edu /~swalton/hol98/src/datatype/mutual/Def_MN_Func.sml (1931 words)

	CSE 130 Lecture Notes
		RECURSIVE TYPES IN ML In ML recursion is allowed with the datatype notation for tagged unions.
		Recursive types are also implemented with pointers in ML.
		Probably the most important advantage of recursive types is that the programmer cannot make pointer manipulation mistakes.
	www-cse.ucsd.edu /~elkan/130fall99/oct18.html (483 words)

	CSE 421: Compiler Construction (Site not responding. Last check: 2007-10-20)
		The presense of recursive type declarations requires some form of circularity in the representation of types.
		However, if we're not careful, we could write functions which recursively traverse through the structure of a type and have this function never terminate due to circularities.
		Almost every time you look up a type identifier (except when processing recursive type decarations), you want to run the result through actual_ty.
	www.cse.psu.edu /~cg421/assignments/hw5ahints.html (403 words)

	Re: Recursive SOP type definitions?
		Type and value contructors live in completely separate name spaces.
		In the latter example, the type expression refers to *type* constructors LBRACKET, NUM and RBRACKET.
		Nor do I understand the purpose of your of lbr_num_rbr type (and it is not used), so I cannot tell how to replace that with something valid.
	www.talkaboutprogramming.com /group/comp.lang.ml/messages/7611.html (317 words)

	DNS.Info : Glossary
		Non-recursive: A name server is defined non-recursive when it does not engage recursion to satisfy a request that it is not authoritative for.
		Recursive: A name server is defined recursive when it will make an attempt to satisfy a DNS request that it does not possess the resource records for.
		Resource Record (RR): One of the defined types of records that may be served by a DNS server.
	dns.info.aol.com /glossary.shtml (141 words)

	[No title] (Site not responding. Last check: 2007-10-20)
		The offset parameter specifies which enclosing struct or union is the target of the recursion, with the value 1 indicating the most immediate enclosing struct or union, and larger values indicating successive enclosing struct or unions.
		The offset parameter specifies which enclosing struct, union or valuetype is the target of the recursion, with the value 1 indicating the most immediate enclosing struct, union or valuetype, and larger values indicating successive enclosing struct, union or valuetype.
		For example, the following IDL type declarations contain recursion:" to: "The create_recursive_tc operation is used to create a recursive TypeCode, which serves as a place holder for a concrete TypeCode during the process of creating TypeCodes that contain recursion.
	www.omg.org /issues/issue2848.txt (1244 words)

	[No title] (Site not responding. Last check: 2007-10-20)
		Recursive types are in use already and plagued by the anonymous type issue already.
		Recursive types are in use already and > plagued > by the anonymous type issue already.
		Because the row type is anonymous, the name of the helper function for Any insertion/extraction is undefined, as is the type of the parameter.
	www.omg.org /issues/issue2275.txt (15140 words)

	[No title]
		The type system is the system of simple types with a type and recursion.
		Due to the presence of recursive types, the result of the type inference is a graph where each node is annotated with a type constructor.
		The M annotation of a type is wired in such a way that it reflects the maximum level +1 at which expressions of that type will be subject to memoization, 0 if they are never memoized.
	www.informatik.uni-freiburg.de /proglang/software/pgg/pgg-manual.html (5775 words)

	[No title]
		Informally, a "recursive" data type is one whose definition refers the the same data type.
		(This type of recursion is not allowed by the language or its compilers).
		If we make a seemingly slight change in the node0 class, we get a type that can be allocated in memory since it only contains 1 int and 1 pointer.
	condor.depaul.edu /~glancast/262class/docs/lecFeb01.html (1039 words)

	PHP: PHP 4 ChangeLog
		Fixed bug #33201 (Crash when fetching some data types).
		Fixed bug #33940 (array_map() fails to pass by reference when called recursively).
		Fixed bug #30573 (compiler warnings in libmbfl due to invalid type cast).
	www.php.net /ChangeLog-4.php (10850 words)

Try your search on: Qwika (all wikis)