Relevant bibliographies by topics / Algebraic datatypes

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Book chapters
  4. Conference papers

Academic literature on the topic 'Algebraic datatypes'

Author: Grafiati
Published: 3 May 2025

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Algebraic datatypes.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Algebraic datatypes"

1

Martinez Lopez, P. "Fork algebraic datatypes." Logic Journal of IGPL 6, no. 4 (July 1, 1998): 531–43. http://dx.doi.org/10.1093/jigpal/6.4.531.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Malewski, Stefan, Michael Greenberg, and Éric Tanter. "Gradually structured data." Proceedings of the ACM on Programming Languages 5, OOPSLA (October 20, 2021): 1–29. http://dx.doi.org/10.1145/3485503.

Full text
Abstract:
Dynamically-typed languages offer easy interaction with ad hoc data such as JSON and S-expressions; statically-typed languages offer powerful tools for working with structured data, notably algebraic datatypes , which are a core feature of typed languages both functional and otherwise. Gradual typing aims to reconcile dynamic and static typing smoothly. The gradual typing literature has extensively focused on the computational aspect of types, such as type safety, effects, noninterference, or parametricity, but the application of graduality to data structuring mechanisms has been much less explored. While row polymorphism and set-theoretic types have been studied in the context of gradual typing, algebraic datatypes in particular have not, which is surprising considering their wide use in practice. We develop, formalize, and prototype a novel approach to gradually structured data with algebraic datatypes. Gradually structured data bridges the gap between traditional algebraic datatypes and flexible data management mechanisms such as tagged data in dynamic languages, or polymorphic variants in OCaml. We illustrate the key ideas of gradual algebraic datatypes through the evolution of a small server application from dynamic to progressively more static checking, formalize a core functional language with gradually structured data, and establish its metatheory, including the gradual guarantees.
APA, Harvard, Vancouver, ISO, and other styles
3

Kuncak, Viktor, and Daniel Jackson. "Relational analysis of algebraic datatypes." ACM SIGSOFT Software Engineering Notes 30, no. 5 (September 2005): 207–16. http://dx.doi.org/10.1145/1095430.1081740.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Zenger, Matthias, and Martin Odersky. "Extensible algebraic datatypes with defaults." ACM SIGPLAN Notices 36, no. 10 (October 2001): 241–52. http://dx.doi.org/10.1145/507669.507665.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Dinesh, T. B., Magne Haveraaen, and Jan Heering. "An Algebraic Programming Style for Numerical Software and Its Optimization." Scientific Programming 8, no. 4 (2000): 247–59. http://dx.doi.org/10.1155/2000/494281.

Full text
Abstract:
The abstract mathematical theory of partial differential equations (PDEs) is formulated in terms of manifolds, scalar fields, tensors, and the like, but these algebraic structures are hardly recognizable in actual PDE solvers. The general aim of the Sophus programming style is to bridge the gap between theory and practice in the domain of PDE solvers. Its main ingredients are a library of abstract datatypes corresponding to the algebraic structures used in the mathematical theory and an algebraic expression style similar to the expression style used in the mathematical theory. Because of its emphasis on abstract datatypes, Sophus is most naturally combined with object-oriented languages or other languages supporting abstract datatypes. The resulting source code patterns are beyond the scope of current compiler optimizations, but are sufficiently specific for a dedicated source-to-source optimizer. The limited, domain-specific, character of Sophus is the key to success here. This kind of optimization has been tested on computationally intensive Sophus style code with promising results. The general approach may be useful for other styles and in other application domains as well.
APA, Harvard, Vancouver, ISO, and other styles
6

Mordido, Andreia, Janek Spaderna, Peter Thiemann, and Vasco T. Vasconcelos. "Parameterized Algebraic Protocols." Proceedings of the ACM on Programming Languages 7, PLDI (June 6, 2023): 1389–413. http://dx.doi.org/10.1145/3591277.

Full text
Abstract:
We propose algebraic protocols that enable the definition of protocol templates and session types analogous to the definition of domain-specific types with algebraic datatypes. Parameterized algebraic protocols subsume all regular as well as most context-free and nested session types and, at the same time, replace the expensive superlinear algorithms for type checking by a nominal check that runs in linear time. Algebraic protocols in combination with polymorphism increase expressiveness and modularity by facilitating new ways of parameterizing and composing session types.
APA, Harvard, Vancouver, ISO, and other styles
7

Koparkar, Chaitanya, Mike Rainey, Michael Vollmer, Milind Kulkarni, and Ryan R. Newton. "Efficient tree-traversals: reconciling parallelism and dense data representations." Proceedings of the ACM on Programming Languages 5, ICFP (August 22, 2021): 1–29. http://dx.doi.org/10.1145/3473596.

Full text
Abstract:
Recent work showed that compiling functional programs to use dense, serialized memory representations for recursive algebraic datatypes can yield significant constant-factor speedups for sequential programs. But serializing data in a maximally dense format consequently serializes the processing of that data, yielding a tension between density and parallelism. This paper shows that a disciplined, practical compromise is possible. We present Parallel Gibbon, a compiler that obtains the benefits of dense data formats and parallelism. We formalize the semantics of the parallel location calculus underpinning this novel implementation strategy, and show that it is type-safe. Parallel Gibbon exceeds the parallel performance of existing compilers for purely functional programs that use recursive algebraic datatypes, including, notably, abstract-syntax-tree traversals as in compilers.
APA, Harvard, Vancouver, ISO, and other styles
8

Zaiser, Fabian, and C. H. Luke Ong. "The Extended Theory of Trees and Algebraic (Co)datatypes." Electronic Proceedings in Theoretical Computer Science 320 (August 7, 2020): 167–96. http://dx.doi.org/10.4204/eptcs.320.14.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Shah, Amar, Federico Mora, and Sanjit A. Seshia. "An Eager Satisfiability Modulo Theories Solver for Algebraic Datatypes." Proceedings of the AAAI Conference on Artificial Intelligence 38, no. 8 (March 24, 2024): 8099–107. http://dx.doi.org/10.1609/aaai.v38i8.28649.

Full text
Abstract:
Algebraic data types (ADTs) are a construct classically found in functional programming languages that capture data structures like enumerated types, lists, and trees. In recent years, interest in ADTs has increased. For example, popular programming languages, like Python, have added support for ADTs. Automated reasoning about ADTs can be done using satisfiability modulo theories (SMT) solving, an extension of the Boolean satisfiability problem with first-order logic and associated background theories. Unfortunately, SMT solvers that support ADTs do not scale as state-of-the-art approaches all use variations of the same lazy approach. In this paper, we present an SMT solver that takes a fundamentally different approach, an eager approach. Specifically, our solver reduces ADT queries to a simpler logical theory, uninterpreted functions (UF), and then uses an existing solver on the reduced query. We prove the soundness and completeness of our approach and demonstrate that it outperforms the state of the art on existing benchmarks, as well as a new, more challenging benchmark set from the planning domain.
APA, Harvard, Vancouver, ISO, and other styles
10

TASSON, CHRISTINE, and LIONEL VAUX. "Transport of finiteness structures and applications." Mathematical Structures in Computer Science 28, no. 7 (December 5, 2016): 1061–96. http://dx.doi.org/10.1017/s0960129516000384.

Full text
Abstract:
We describe a general construction of finiteness spaces which subsumes the interpretations of all positive connectors of linear logic. We then show how to apply this construction to prove the existence of least fixpoints for particular functors in the category of finiteness spaces: These include the functors involved in a relational interpretation of lazy recursive algebraic datatypes along the lines of the coherence semantics of system T.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Algebraic datatypes"

1

Le, Normand Jacques. "Generalized algebraic datatypes: a different approach." Thesis, McGill University, 2007. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=18303.

Full text
Abstract:
We offer an alternative method for type checking expressions in an extension of Hindley and Milner’s lambda calculus with generalized algebraic data types. The approach foregoes all mention of type equalities and unifiers and only applies type conversions at case statements in a deterministic fashion. What we introduce is a method for finding out the appropriate types of pattern bound variables within a type derivation and how to convert them back so that they are valid types in the context of the enclosing expression. Everything is done locally so scoping is no longer an issue. The system is proven sound and complete. An implementation of the system is discussed.
Ce document propose une methode alternative de verification du type dans une extension du systeme de typage de Hindley et Milner avec des types de donnees algebriques generalises. Cette methode n’utilise pas d’unificateur et d’egalite de type. De plus, elle ne convertit les types qu’a l’expression de case, et ce de maniere deterministique. Tout est fait localement dans ce systeme. Le systeme est prouve complet et correcte et une implementation est decrite.
APA, Harvard, Vancouver, ISO, and other styles
2

Losekoot, Théo. "Automatic program verification by inference of relational models." Electronic Thesis or Diss., Université de Rennes (2023-....), 2024. http://www.theses.fr/2024URENS102.

Full text
Abstract:
Cette thèse porte sur la preuve automatique de propriétés concernant la relation entrée/sortie de programmes fonctionnels manipulant des types de données algébriques (ADT). De récents résultats montrent comment approximer un programme fonctionnel en utilisant un automate d'arbre. Bien qu'expressives, ces techniques ne peuvent pas prouver de propriété reliant l'entrée et la sortie d'une fonction, par exemple qu'inverser une liste préserve sa longueur. Dans cette thèse, nous nous appuyons sur ces résultats et définissons une procédure pour calculer ou sur-approximer une telle relation. Formellement, le problème de la vérification de programmes se réduit à la satisfiabilité de clauses, que nous résolvons en exhibant un modèle. Dans cette thèse, nous proposons deux représentations relationnelles de ces modèles de Herbrand : les automates d'arbres convolués et les shallow Horn clauses. Les automates d'arbres convolués généralisent les automates d'arbres et sont généralisés par les shallow Horn clauses. Le problème d'inférence du modèle de Herbrand découlant de la vérification relationnelle étant indécidable, nous proposons une procédure d'inférence incomplète mais correcte. Les expériences montrent que cette procédure est performante en pratique par rapport aux outils actuels, à la fois pour la vérification des propriétés et pour la recherche de contre-exemples
This thesis is concerned with automatically proving properties about the input/output relation of functional programs operating over algebraic data types. Recent results show how to approximate the image of a functional program using a regular tree language. Though expressive, those techniques cannot prove properties relating the input and the output of a function, e.g., proving that the output of a function reversing a list has the same length as the input list. In this thesis, we build upon those results and define a procedure to compute or over-approximate such a relation, thereby allowing to prove properties that require a more precise relational representation. Formally, the program verification problem reduces to satisfiability of clauses over the theory of algebraic data types, which we solve by exhibiting a Herbrand model of the clauses. In this thesis, we propose two relational representations of these Herbrand models: convoluted tree automata and shallow Horn clauses. Convoluted tree automata generalize tree automata and are in turn generalized by shallow Horn clauses. The Herbrand model inference problem arising from relational verification is undecidable, so we propose an incomplete but sound inference procedure. Experiments show that this procedure performs well in practice w.r.t. state of the art tools, both for verifying properties and for finding counterexamples
APA, Harvard, Vancouver, ISO, and other styles
3

Kuncak, Viktor, and Daniel Jackson. "On Relational Analysis of Algebraic Datatypes." 2005. http://hdl.handle.net/1721.1/30534.

Full text
Abstract:
We present a technique that enables the use of finite modelfinding to check the satisfiability of certain formulaswhose intended models are infinite. Such formulas arisewhen using the language of sets and relations to reasonabout structured values such as algebraic datatypes. Thekey idea of our technique is to identify a natural syntacticclass of formulas in relational logic for which reasoningabout infinite structures can be reduced to reasoning aboutfinite structures. As a result, when a formula belongs tothis class, we can use existing finite model findingtools to check whether the formula holds in the desiredinfinite model.
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "Algebraic datatypes"

1

Benton, P. N. "Strictness properties of lazy algebraic datatypes." In Static Analysis, 206–17. Berlin, Heidelberg: Springer Berlin Heidelberg, 1993. http://dx.doi.org/10.1007/3-540-57264-3_42.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Baumeister, Hubert. "Relating Abstract Datatypes and Z-Schemata." In Recent Trends in Algebraic Development Techniques, 366–82. Berlin, Heidelberg: Springer Berlin Heidelberg, 2000. http://dx.doi.org/10.1007/978-3-540-44616-3_21.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Sheng, Ying, Yoni Zohar, Christophe Ringeissen, Jane Lange, Pascal Fontaine, and Clark Barrett. "Politeness for the Theory of Algebraic Datatypes." In Automated Reasoning, 238–55. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-51074-9_14.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Padberg, Julia. "Abstract Datatype Semantics for Algebraic High-Level Nets Using Dynamic Abstract Datatypes." In Quality of Communication-Based Systems, 1–17. Dordrecht: Springer Netherlands, 1995. http://dx.doi.org/10.1007/978-94-011-0187-5_1.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Blanchette, Jasmin Christian. "Relational Analysis of (Co)inductive Predicates, (Co)algebraic Datatypes, and (Co)recursive Functions." In Tests and Proofs, 117–34. Berlin, Heidelberg: Springer Berlin Heidelberg, 2010. http://dx.doi.org/10.1007/978-3-642-13977-2_11.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Péchoux, Romain, Simon Perdrix, Mathys Rennela, and Vladimir Zamdzhiev. "Quantum Programming with Inductive Datatypes: Causality and Affine Type Theory." In Lecture Notes in Computer Science, 562–81. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-45231-5_29.

Full text
Abstract:
AbstractInductive datatypes in programming languages allow users to define useful data structures such as natural numbers, lists, trees, and others. In this paper we show how inductive datatypes may be added to the quantum programming language QPL. We construct a sound categorical model for the language and by doing so we provide the first detailed semantic treatment of user-defined inductive datatypes in quantum programming. We also show our denotational interpretation is invariant with respect to big-step reduction, thereby establishing another novel result for quantum programming. Compared to classical programming, this property is considerably more difficult to prove and we demonstrate its usefulness by showing how it immediately implies computational adequacy at all types. To further cement our results, our semantics is entirely based on a physically natural model of von Neumann algebras, which are mathematical structures used by physicists to study quantum mechanics.
APA, Harvard, Vancouver, ISO, and other styles
7

Jenks, Richard D., Robert S. Sutor, and Stephen M. Watt. "Scratchpad II: An abstract datatype system for mathematical computation." In Trends in Computer Algebra, 12–37. Berlin, Heidelberg: Springer Berlin Heidelberg, 1988. http://dx.doi.org/10.1007/3-540-18928-9_3.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Baumeister, Hubert. "Relations as abstract datatypes: An institution to specify relations between algebras." In TAPSOFT '95: Theory and Practice of Software Development, 756–71. Berlin, Heidelberg: Springer Berlin Heidelberg, 1995. http://dx.doi.org/10.1007/3-540-59293-8_233.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Popescu, Andrei. "Rensets and Renaming-Based Recursion for Syntax with Bindings." In Automated Reasoning, 618–39. Cham: Springer International Publishing, 2022. http://dx.doi.org/10.1007/978-3-031-10769-6_36.

Full text
Abstract:
AbstractI introduce renaming-enriched sets (rensets for short), which are algebraic structures axiomatizing fundamental properties of renaming (also known as variable-for-variable substitution) on syntax with bindings. Rensets compare favorably in some respects with the well-known foundation based on nominal sets. In particular, renaming is a more fundamental operator than the nominal swapping operator and enjoys a simpler, equationally expressed relationship with the variable-freshness predicate. Together with some natural axioms matching properties of the syntactic constructors, rensets yield a truly minimalistic characterization of $$\lambda $$ λ -calculus terms as an abstract datatype – one involving an infinite set of unconditional equations, referring only to the most fundamental term operators: the constructors and renaming. This characterization yields a recursion principle, which (similarly to the case of nominal sets) can be improved by incorporating Barendregt’s variable convention. When interpreting syntax in semantic domains, my renaming-based recursor is easier to deploy than the nominal recursor. My results have been validated with the proof assistant Isabelle/HOL.
APA, Harvard, Vancouver, ISO, and other styles
10

Ellis, Graham. "Path Components and the Fundamental Group." In An Invitation to Computational Homotopy, 1–126. Oxford University Press, 2019. http://dx.doi.org/10.1093/oso/9780198832973.003.0001.

Full text
Abstract:
This chapter introduces some of the basic concepts of algebraic topology and describes datatypes and algorithms for implementing them on a computer. The basic concepts include: regular CW-complex, non-regular CW-complex, simplicial complex, cubical complex, permutahedral complex, simple homotopy, set of path-components, fundamental group, van Kampen’s theorem, knot quandle, Alexander polynomial of a knot, covering space. These are illustrated using computer examples involving digital images, protein backbones, high-dimensional point cloud data, knot complements, discrete groups, and random simplicial complexes.
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Algebraic datatypes"

1

Kuncak, Viktor, and Daniel Jackson. "Relational analysis of algebraic datatypes." In the 10th European software engineering conference held jointly with 13th ACM SIGSOFT international symposium. New York, New York, USA: ACM Press, 2005. http://dx.doi.org/10.1145/1081706.1081740.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Vassena, Marco. "Generic Diff3 for algebraic datatypes." In ICFP'16: ACM SIGPLAN International Conference on Functional Programming. New York, NY, USA: ACM, 2016. http://dx.doi.org/10.1145/2976022.2976026.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Zenger, Matthias, and Martin Odersky. "Extensible algebraic datatypes with defaults." In the sixth ACM SIGPLAN international conference. New York, New York, USA: ACM Press, 2001. http://dx.doi.org/10.1145/507635.507665.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Sheng, Ying, Yoni Zohar, Christophe Ringeissen, Jane Lange, Pascal Fontaine, and Clark Barrett. "Politeness for the Theory of Algebraic Datatypes (Extended Abstract)." In Thirtieth International Joint Conference on Artificial Intelligence {IJCAI-21}. California: International Joint Conferences on Artificial Intelligence Organization, 2021. http://dx.doi.org/10.24963/ijcai.2021/660.

Full text
Abstract:
Algebraic datatypes, and among them lists and trees, have attracted a lot of interest in automated reasoning and Satisfiability Modulo Theories (SMT). Since its latest stable version, the SMT-LIB standard defines a theory of algebraic datatypes, which is currently supported by several mainstream SMT solvers. In this paper, we study this particular theory of datatypes and prove that it is strongly polite, showing also how it can be combined with other arbitrary disjoint theories using polite combination. Our results cover both inductive and finite datatypes, as well as their union. The combination method uses a new, simple, and natural notion of additivity, that enables deducing strong politeness from (weak) politeness.
APA, Harvard, Vancouver, ISO, and other styles
5

Rahaman, Sydur, Iulian Neamtiu, and Xin Yin. "Algebraic-datatype taint tracking, with applications to understanding Android identifier leaks." In ESEC/FSE '21: 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. New York, NY, USA: ACM, 2021. http://dx.doi.org/10.1145/3468264.3468550.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Algebraic datatypes' for particular source types:
Journal articles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography