
	Where results make sense

Topic: Algebraic data type

Related Topics

abstract algebra

algebraic geometry

linear algebra

algebraic topology

Boolean algebra

Lie algebra

algebraic varieties

basis linear algebra

ring algebra

associative algebra

algebraic notation

homological algebra

In the News (Tue 22 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Data type - Wikipedia, the free encyclopedia
		Data type is a type of data in a type system in computer programming.
		Types of data in programming languages include primitive types, tuples, records, algebraic data types, abstract data types, reference types, classes, and nodes of data structures.
		The smallest addressable unit of data is a group of bits called a byte (usually an octet, which is 8 bits).
	en.wikipedia.org /wiki/Data_type (361 words)

	Algebraic data type - Wikipedia, the free encyclopedia
		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).
		Languages with more expressive type systems based upon something similar to System-Fω (i.e., systems that use kinds, where a kind serves as a "type of a type"), such as Haskell, may however use constructors directly in substitution of a normal function.
	en.wikipedia.org /wiki/Algebraic_data_types (727 words)

	Syntax Definition for Language Prototyping: Introduction
		The structure of the types used in the signature of a specification is specified by means of an algebraic specification itself.
		Type assignment is an extension of the Hindley/Milner algorithm to many-sorted types, multi-levels and overloading of functions.
		Moreover, types and object level data are specified by means of a context-free grammar instead of with a signature, leading to flexible notation.
	www.cs.uu.nl /people/visser/thesis/intro.html (3900 words)

	algebraic data type (Site not responding. Last check: 2007-10-21)
		Such a type is known as an algebraic data type.
		The most common algebraic data type is the list which has constructors Nil and Cons, written in Haskell using the special syntax "[]" for Nil and infix ":" for Cons.
		Objects of such a type can only be manipulated using functions defined in the same module as the type itself.
	burks.bton.ac.uk /burks/foldoc/28/4.htm (287 words)

	Multi-Level Specifications (new papers)
		[------ The Types Forum ------- http://www.dcs.gla.ac.uk/~types ------] Multi-level specification is an extension of first-order many-sorted algebraic specification that incorporates the definition of types in the formalism itself.
		In general, the terms used as types in level n are defined in level n+1.
		In multi-level algebraic specification the structure of types used in function declarations is specified as an algebraic data type.
	www.cis.upenn.edu /~bcpierce/types/archives/1996/msg00279.html (497 words)

	Algebraic and Logical Methods at Swansea
		Algebraic specifications of methods are used by NAH in the formal documentation of object-oriented code with tools for animating specifications based on the Maude rewriting system.
		Algebraic methods for modelling microprocessors at instruction set architecture (ISA) and microarchitecture levels of abstraction, and for proving their equivalence, have been developed and extended to pipelined and superscalar processors.
		The algebraic methods research for the design of topological data types and synchronous concurrent algorithms is also being applied to software for whole heart modelling and simulation.
	www.cs.swan.ac.uk /~csjvt/JVTResearch/LAMResearchAreas.html (1349 words)

	Basic Haskell: data types and classes
		Data constructors such as Nil and Cons for lists are applied like functions, but they are really only "place-holders" which build larger structures from smaller ones
		Haskell has a rich type system which supports powerful data structuring techniques: data types may be "higher-order" (viewed as functions from types to types) and recursion may be nested
		In addition to powerful data types, Haskell allows types to be classified into groups based on the availability of functions matching a particular interface specification (as in many O-O languages)
	www.willamette.edu /~fruehr/haskell/lectures/tutorial6.html (264 words)

	The Zephyr Abstract Syntax Description Language (Site not responding. Last check: 2007-10-21)
		From the definitions in Figure 3, it is easy to automatically generate data type declarations in target languages such as C, C++, Java, and ML.
		There are several obvious ways to automatically generate type names for the expressions, however it would be preferable to require description writers to provide semantically meaningful names to these intermediate types, since generated code is intended to be readable by the programmer.
		A proposal for the abstract syntax of ASDL was written using the algebraic data type notation of ML.
	www.cs.princeton.edu /~danwang/Papers/dsl97/dsl97.html (6337 words)

	Semantic Specification in Modula-2 and Ada
		It is essential that the external interface provided to users of an abstract data type should provide a lucid and unambiguous specification of both the syntax and the semantics of an abstract data type.
		Algebraic specifications are similar in structure to abstract data types.
		A further reason for confining the operations of an algebraic specification to functions is that procedures, which are often used to implement the operations of an abstract data type, have no obvious mathematical counterpart.
	scom.hud.ac.uk /scomtlm/book/node214.html (640 words)

	[No title]
		Although Haskell provides for convenient definition of data types and structures, lists are pre-defined and ubiquitous (storage is automatically allocated and collected) 2.
		Data constructors such as Nil and Cons for lists are applied like functions, but they are really only "place-holders" which build larger structures from smaller ones 3.
		We can define our own data types in Haskell and use their constructors to build data structures or in pattern-matching to define functions on these structures b.
	www.willamette.edu /~fruehr/haskell/lectures/tutorial (1571 words)

	CSE 130 Lecture Notes
		The basic difference between abstract data types (ADTs) and concrete data types is that the latter allow us to look at the concrete representation, whereas the former hide the representation from us.
		NodeBT BinTree BinTree -- Polymorphic Algebraic type: data XTree a = LeafXT a
		All the types in a package typically provide related functionality and are implemented by the same person or team, so it is reasonable for the classes in a package to have access to each other's implementation, i.e.
	users.sdsc.edu /~ludaesch/CSE130/ln8.html (1175 words)

	Spring School on Datatype-Generic Programming 2006 \| Lambda the Ultimate
		Algebraic datatypes are typeful in a way that s-expressions aren't, and have more fundamental structure (s-expressions desugar to a pile of cons cells).
		If you were in an explicitly-typed language, you might use this type parameter by plunking it down in the type constraints that appear somewhere in the body code (say in the type of a function argument).
		My favorite examples have to do with functions that are polymorphic (oops, polytypic!) in a data structure: size, depth, map, etc., defined not just for lists or for binary trees, or for multi-branch trees, etc., but for any (algebraic) data structure, once and for all.
	lambda-the-ultimate.org /node/view/1234 (3087 words)

	Prospering With Miranda
		For example, a composite type which allows the labelling of individual blooms could be defined, so that: ``the type tag consists of a labelled bloom and a string, or a bloom with no label''.
		These are like algebraic types with no constructors; they allow us to ``hold a place during program development'', so that we can provide a more specific type definition later.
		Generally, the specification for ADTs consists of the type name, a list of the operations that can be performed on the type, and an optional spec of the range of values that the type may assume.
	www.progsoc.uts.edu.au /tfm/tfm97/node39.html (1254 words)

	Haskell Tutorial (Site not responding. Last check: 2007-10-21)
		Bound variables and type variables are denoted by identifiers beginning with a lowercase letter; types, constructors, modules, and classes are denoted by identifiers beginning with an uppercase letter.
		Haskell permits the definition of abstract types, whose implementation is hidden from the rest of the program.
		The elements of a tuple may be of mixed type and tuples are written with parentheses and commas.
	cs.wwc.edu /~cs_dept/KU/PR/Haskell.html (3443 words)

	Enterprise XML Schema Advice Needed (by Jeremy Zawodny)
		All base type sets such as equities, options, and other contracts should consist of collections of type information based solely within the XML schema domain dates, currency values, etc. We can imagine that base type sets will not change too frequently; a simple equity will always be a simple equity.
		Once your groupings of the base types are established and the groupings of these base types are created to satisfy your needs in each of your subject areas, you will have a very large data model, consisting of many pieces.
		Literally you need to construct a second data model representing your expectations of the change in your first data model, it is this second data model that will help you map your representation to namespaces and other XML Schema specific domain needs.
	jeremy.zawodny.com /blog/archives/000286.html (1351 words)

	T9: GADT (Site not responding. Last check: 2007-10-21)
		Basically, an algebraic type consists of a set of constructors that take different arguments, and can be recursive.
		The return type of the constructor functions is always the type of the whole structure, so e.g.
		I think the main reason that ADTs aren't modelled that way is because the list of subclasses is open via subclassing, whereas for ADTs the list is closed, which allows you to compile pattern matching into a simple jump, and also allows a compiler to statically check that all cases are satisfied.
	www.equi4.com /t9/80?view=print (616 words)

	Constraint-Based Type Inference for Guarded Algebraic Data Types \| Lambda the Ultimate
		Guarded algebraic data types subsume the concepts known in the literature as indexed types, guarded recursive datatype constructors, and first-class phantom types, and are closely related to inductive types.
		We prove that the type system is sound and that, provided recursive function definitions carry a type annotation, type inference may be reduced to constraint solving.
		To the best of our knowledge, this is the first generic and comprehensive account of type inference in the presence of guarded algebraic data types.
	lambda-the-ultimate.org /node/view/14 (244 words)

	The Memory Management Glossary: S
		A scalar data type is a type that is representable in a single dimension and whose objects have only magnitude as value.
		type in C is defined to have a magnitude that can be represented by a word.
		Store can also be used in the more general sense of transferring data from a part of the memory hierarchy that is fast to access to one that is slow to access.
	www.memorymanagement.org /glossary/s.html (3651 words)

	Information Visualization and Semiotic Morphisms
		The main reference for algebraic semiotics is [2]; an informal exposition of some main ideas and their motivation is given in the webnote Semiotic Morphisms, and an (intendedly) amusing introduction is given in the UCSD Semiotic Zoo.
		The designer must be sensitive to features of the data to create a useful visualization, but certain structural features may not be obvious, and it may be even less obvious which of them are the most important.
		This insight is not unique to algebraic semiotics; for example, the importance of social factors in HCI is the focus of its CSCW subfield.
	www-cse.ucsd.edu /~goguen/papers/sm/vzln.html (4240 words)

	Simple unification-based type inference for GADTs (Site not responding. Last check: 2007-10-21)
		Generalized algebraic data types (GADTs), sometimes known as "guarded recursive data types" or "first-class phantom types", are a simple but powerful generalization of the data types of Haskell and ML.
		Recent works have given compelling examples of the utility of GADTs, although type inference is known to be difficult.
		Our main technical innovation is wobbly types, which express in a declarative way the uncertainty caused by the incremental nature of typical type-inference algorithms.
	research.microsoft.com /Users/simonpj/papers/gadt (125 words)

	[No title]
		Derives the Data and Typeable instances for a single given data type.
		For instance you may -- be transforming another data type that contains other data types, -- some of which you wish to transform (perhaps recursively) and -- some which you just wish to return unchanged.
		However, should the -- interface to the ADT be sufficiently rich it is possible to -- define you're own Data and Typeable instances.
	homepages.cwi.nl /~ralf/syb3/src/Derive.hs (731 words)

	Data structures
		A generic data model is the only practical approach for implementing a generic XML parser and a framework for processing any XML documents.
		Together both types are mutually recursive and form a multi-branch tree structure.
		They are used to specify a general recursive data type for XML documents.
	www.fh-wedel.de /~si/HXmlToolbox/thesis/x558.html (1103 words)

	Avoiding algebraic data types (Site not responding. Last check: 2007-10-21)
		Some of the algebraic data type constructors in the Pseudoknot program are rather large, with up to 34 components.
		For Sisal all algebraic data types were replaced by arrays, since Sisal compilers are specifically optimised towards the efficient handling of arrays.
		Trafola and RUFL implement algebraic data types as linked lists of cells, which implies a significant performance penalty for the large constructors used by Pseudoknot.
	www-fp.dcs.st-and.ac.uk /~kh/papers/pseudoknot/subsubsection3_5_6_2.html (154 words)

	The Memory Management Glossary: V
		Usually these types are a scalar data type with bounded magnitude.
		A vector data type is an aggregate type of more than one dimension whose objects have a value for each dimension, where each dimension is of the same type.
		Relevance to memory management: Vector data types are seldom represented using value objects, but may be represented using leaf objects if they are an aggregate of a type that can be represented by value objects.
	www.memorymanagement.org /glossary/v.html (805 words)

	WWC CS Department (Site not responding. Last check: 2007-10-21)
		Type expressions are syntactic terms which denote type values (or just types).
		The other main consequence of lazy evaluation is that it makes it possible to write down definitions of infinite data structures.
		While Haskell does not require explicit type declarations (the type inference system provides static type checking), it is good programming practice to provide explicit type declarations.
	cs.wwc.edu /~cs_dept/KU/PR/Haskell.php (3451 words)

	Simon Peyton Jones: papers (Site not responding. Last check: 2007-10-21)
		Wobbly types: type inference for generalised algebraic data types
		Generalised algebraic data types (GADTs), sometimes known as "guarded recursive data types" or "first-class phantom types", are a simple but powerful generalisation of the data types of Haskell and ML.
		We answer these questions in the affirmative, giving a type system that explains just what type annotations are required, and a prototype implementation that implements it.
	research.microsoft.com /Users/simonpj/papers/gadt/old-wobbly.htm (209 words)

	Poetix » Blog Archive » Type discipline and missing values
		is an ordinary parameterized algebraic data type, just like any other parameterized algebraic data type in Haskell, that the subtypes we have declared are also ordinary types and that the values we have assigned are ordinary values.
		It is nonsensical to compare a string-typed value to a value of a type whose values range over the discriminated union of the values of the types
		However, there may be cases when the use of a nullable field provides an acceptable representation of the type of value we wish to assert: far from being by definition absurd, it is possible for
	codepoetics.com /poetix/index.php?p=60 (674 words)

Try your search on: Qwika (all wikis)