DOCSLIB.ORG

A Category Theoretic Introduction to Computer Science

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A Category Theoretic Introduction to Computer Science A category theoretic introduction to computer science Thomas Wright June 2016 The wrong answer: Computer science is the study of computers. A better answer: Computer science is the study of computation. What is computer science? A better answer: Computer science is the study of computation. What is computer science? The wrong answer: Computer science is the study of computers. What is computer science? The wrong answer: Computer science is the study of computers. A better answer: Computer science is the study of computation. Part I An abstract theory of computation Example: computing a mathematical function The successor function: f : N0 ! N0 : x 7! x + 1 We can compute this using a computer program written in, for example, C: intf(intn){ returnn+1; } Example: computing a mathematical function We could however have written the same program in a different language: Python: Matlab: deff(n): functionm=f(n) returnn+1 m=n+1 end We can use the following 3 rules to define when two expressions are equivalent: ∼ λx:f =α λy:f [y=x] ∼ (λx:f )g =β f [g=x] ∼ (λx:fx) =η f It turns out the definitions on this slide are enough to give a foundation for both mathematics and computation. Example: Defining and computing with natural numbers The λ-calculus We can express such functions as λ-terms, which can have form: x fg λx:f where x is a variable and f and g are themselves λ-terms. Example: Defining and computing with natural numbers The λ-calculus We can express such functions as λ-terms, which can have form: x fg λx:f where x is a variable and f and g are themselves λ-terms. We can use the following 3 rules to define when two expressions are equivalent: ∼ λx:f =α λy:f [y=x] ∼ (λx:f )g =β f [g=x] ∼ (λx:fx) =η f It turns out the definitions on this slide are enough to give a foundation for both mathematics and computation. The λ-calculus We can express such functions as λ-terms, which can have form: x fg λx:f where x is a variable and f and g are themselves λ-terms. We can use the following 3 rules to define when two expressions are equivalent: ∼ λx:f =α λy:f [y=x] ∼ (λx:f )g =β f [g=x] ∼ (λx:fx) =η f It turns out the definitions on this slide are enough to give a foundation for both mathematics and computation. Example: Defining and computing with natural numbers That is, we treat integers as fundamental and take them to form a primitive type Int. We also take booleans (which can take value either true or false) to be a primitive type Bool. From these primitive types, we can form compound types: A ! BA × B We also add operations to our language for working with each of these types: +, ∗, h·; ·i, fst, snd Adding types To make the λ-calculus more useful, it helps if we avoid unravelling the definition of a natural number just to say 1 + 1 = 2. We then need to move beyond treating everything as a function, and allow values to take different types. From these primitive types, we can form compound types: A ! BA × B We also add operations to our language for working with each of these types: +, ∗, h·; ·i, fst, snd Adding types To make the λ-calculus more useful, it helps if we avoid unravelling the definition of a natural number just to say 1 + 1 = 2. We then need to move beyond treating everything as a function, and allow values to take different types. That is, we treat integers as fundamental and take them to form a primitive type Int. We also take booleans (which can take value either true or false) to be a primitive type Bool. Adding types To make the λ-calculus more useful, it helps if we avoid unravelling the definition of a natural number just to say 1 + 1 = 2. We then need to move beyond treating everything as a function, and allow values to take different types. That is, we treat integers as fundamental and take them to form a primitive type Int. We also take booleans (which can take value either true or false) to be a primitive type Bool. From these primitive types, we can form compound types: A ! BA × B We also add operations to our language for working with each of these types: +, ∗, h·; ·i, fst, snd The λ-calculus as category theory It turns out that the λ-calculus forms a category: The objects are types. The arrows are λ-terms upto equivalence e.g. Hom(A; B) consists of all equivalence classes [f ] of λ-terms f of type A ! B. 1A = [λx:x] (where x : A) [f ] ◦ [g] = [λx:f (gx)] (Verify axioms) Question: What would coproduct types look like? The λ-calculus as category theory C a (a;b) b ~ ! AAo × B / B pA=λz:fst(z) pB =λz:snd(z) where (a; b) = λc:hac; bci The λ-calculus as category theory C a (a;b) b ~ ! AAo × B / B pA=λz:fst(z) pB =λz:snd(z) where (a; b) = λc:hac; bci Question: What would coproduct types look like? More surprisingly, any cartesian closed category arises from the simply typed λ-calculus. The theory of cartesian closed categories is exactly the simply typed λ-calculus. The λ-calculus as category theory We can also extend our type system with a unit type Unit which contains only the value hi (the empty product type); this provides the category of types with a terminal object. Then the category of types of the λ-calculus is cartesian closed: Definition A category C is cartesian closed if it has all finite products and all exponentials. The λ-calculus as category theory We can also extend our type system with a unit type Unit which contains only the value hi (the empty product type); this provides the category of types with a terminal object. Then the category of types of the λ-calculus is cartesian closed: Definition A category C is cartesian closed if it has all finite products and all exponentials. More surprisingly, any cartesian closed category arises from the simply typed λ-calculus. The theory of cartesian closed categories is exactly the simply typed λ-calculus. Part II Computation with the messy bits left in Surprise: programming is difficult Actually, there is more to programming than we have hinted at. Studying programs upto βη-equivalence gives a theory of computable functions. However real computer programs do many things not captured by a theory of functions: • Crash • Loop forever • Act randomly • Input and output data • Change global state We need to extend out theory of computation in order to capture this behaviour; we can do this using monads. Monads A monad over a category C is a triple (T ; η; µ) where T : C!C is 2 a functor, η : 1C ! T and µ : T ! T are natural transformations making the following diagrams commute: µTA µ T µ T 3A / T 2A TA / 2 o A TA^ T A TA@ 1TA 1TA T µA µA µA T 2A / TA µA TA Kleisli triples A Kleisli triple over a category C is a triple (T ; µ, ∗) where T : Obj(C) ! Obj(C), νA : A ! TA for A 2 Obj(C), and f ∗ : TA ! TB for f : A ! TB and the following equations hold: ∗ • µA = 1TA; ∗ • f ◦ µA = f for f : A ! TB; • g ∗ ◦ f ∗ = (g ∗ ◦ f )∗ Notions of computation Using a Kleisli triple to define a monad gives a model of computation: • T is a notion of computation; it takes types of values to types of computations. • The unit µA takes a value of type A to a program which computes this value. • Given a function f on values, we extend it to a function f ∗ on computations by applying the function to the result of the computation. Then the programs in this model come from the Kleisli category CT of the monad. Partial computation • TA = A + f?g where ? denotes the diverging computation (that is, the program breaking). • µA is inclusion. • if f : A ! TB then f ∗(?) = ? f ∗(a) = f (a) Nondeterminism • TA = Pfin(A). • µA(a) = fag. • if f : A ! TB and c 2 TA then [ f ∗(c) = f (a) x2c Side-effects • TA = (A × S)S . • µA(a) = λs : S:ha; si. • if f : A ! TB and c 2 TA then f ∗ evaluates f given stored data s and updates the store. Part III Haskell: a category theory based programming language Introducing Haskell Haskell takes these models of computation and turns them into an actual programming language. Successor: Hello world: f:: Int -> Int main::IO() fn=n+1 main= putStrLn "Hello, World!" Sources on Monads in Haskell: • http://learnyouahaskell.com/input-and-output • https://www.schoolofhaskell.com/school/ starting-with-haskell/basics-of-haskell/ the-tao-of-monad.
Load more

Recommended publications
  • Finite Sum – Product Logic
    Theory and Applications of Categories, Vol. 8, No. 5, pp. 63–99. FINITE SUM – PRODUCT LOGIC J.R.B. COCKETT1 AND R.A.G. SEELY2 ABSTRACT. In this paper we describe a deductive system for categories with finite products and coproducts, prove decidability of equality of morphisms via cut elimina- tion, and prove a “Whitman theorem” for the free such categories over arbitrary base categories. This result provides a nice illustration of some basic techniques in categorical proof theory, and also seems to have slipped past unproved in previous work in this field. Furthermore, it suggests a type-theoretic approach to 2–player input–output games. Introduction In the late 1960’s Lambekintroduced the notion of a “deductive system”, by which he meant the presentation of a sequent calculus for a logic as a category, whose objects were formulas of the logic, and whose arrows were (equivalence classes of) sequent deriva- tions. He noticed that “doctrines” of categories corresponded under this construction to certain logics. The classic example of this was cartesian closed categories, which could then be regarded as the “proof theory” for the ∧ – ⇒ fragment of intuitionistic propo- sitional logic. (An excellent account of this may be found in the classic monograph [Lambek–Scott 1986].) Since his original work, many categorical doctrines have been given similar analyses, but it seems one simple case has been overlooked, viz. the doctrine of categories with finite products and coproducts (without any closed structure and with- out any extra assumptions concerning distributivity of the one over the other). We began looking at this case with the thought that it would provide a nice simple introduction to some techniques in categorical proof theory, particularly the idea of rewriting systems modulo equations, which we have found useful in investigating categorical structures with two tensor products (“linearly distributive categories” [Blute et al.
    [Show full text]
  • 1. Directed Graphs Or Quivers What Is Category Theory? • Graph Theory on Steroids • Comic Book Mathematics • Abstract Nonsense • the Secret Dictionary
    1. Directed graphs or quivers What is category theory? • Graph theory on steroids • Comic book mathematics • Abstract nonsense • The secret dictionary Sets and classes: For S = fX j X2 = Xg, have S 2 S , S2 = S Directed graph or quiver: C = (C0;C1;@0 : C1 ! C0;@1 : C1 ! C0) Class C0 of objects, vertices, points, . Class C1 of morphisms, (directed) edges, arrows, . For x; y 2 C0, write C(x; y) := ff 2 C1 j @0f = x; @1f = yg f 2C1 tail, domain / @0f / @1f o head, codomain op Opposite or dual graph of C = (C0;C1;@0;@1) is C = (C0;C1;@1;@0) Graph homomorphism F : D ! C has object part F0 : D0 ! C0 and morphism part F1 : D1 ! C1 with @i ◦ F1(f) = F0 ◦ @i(f) for i = 0; 1. Graph isomorphism has bijective object and morphism parts. Poset (X; ≤): set X with reflexive, antisymmetric, transitive order ≤ Hasse diagram of poset (X; ≤): x ! y if y covers x, i.e., x 6= y and [x; y] = fx; yg, so x ≤ z ≤ y ) z = x or z = y. Hasse diagram of (N; ≤) is 0 / 1 / 2 / 3 / ::: Hasse diagram of (f1; 2; 3; 6g; j ) is 3 / 6 O O 1 / 2 1 2 2. Categories Category: Quiver C = (C0;C1;@0 : C1 ! C0;@1 : C1 ! C0) with: • composition: 8 x; y; z 2 C0 ; C(x; y) × C(y; z) ! C(x; z); (f; g) 7! g ◦ f • satisfying associativity: 8 x; y; z; t 2 C0 ; 8 (f; g; h) 2 C(x; y) × C(y; z) × C(z; t) ; h ◦ (g ◦ f) = (h ◦ g) ◦ f y iS qq <SSSS g qq << SSS f qqq h◦g < SSSS qq << SSS qq g◦f < SSS xqq << SS z Vo VV < x VVVV << VVVV < VVVV << h VVVV < h◦(g◦f)=(h◦g)◦f VVVV < VVV+ t • identities: 8 x; y; z 2 C0 ; 9 1y 2 C(y; y) : 8 f 2 C(x; y) ; 1y ◦ f = f and 8 g 2 C(y; z) ; g ◦ 1y = g f y o x MM MM 1y g MM MMM f MMM M& zo g y Example: N0 = fxg ; N1 = N ; 1x = 0 ; 8 m; n 2 N ; n◦m = m+n ; | one object, lots of arrows [monoid of natural numbers under addition] 4 x / x Equation: 3 + 5 = 4 + 4 Commuting diagram: 3 4 x / x 5 ( 1 if m ≤ n; Example: N1 = N ; 8 m; n 2 N ; jN(m; n)j = 0 otherwise | lots of objects, lots of arrows [poset (N; ≤) as a category] These two examples are small categories: have a set of morphisms.
    [Show full text]
  • Chapter 2 of Concrete Abstractions: an Introduction to Computer
    Out of print; full text available for free at http://www.gustavus.edu/+max/concrete-abstractions.html CHAPTER TWO Recursion and Induction 2.1 Recursion We have used Scheme to write procedures that describe how certain computational processes can be carried out. All the procedures we've discussed so far generate processes of a ®xed size. For example, the process generated by the procedure square always does exactly one multiplication no matter how big or how small the number we're squaring is. Similarly, the procedure pinwheel generates a process that will do exactly the same number of stack and turn operations when we use it on a basic block as it will when we use it on a huge quilt that's 128 basic blocks long and 128 basic blocks wide. Furthermore, the size of the procedure (that is, the size of the procedure's text) is a good indicator of the size of the processes it generates: Small procedures generate small processes and large procedures generate large processes. On the other hand, there are procedures of a ®xed size that generate computa- tional processes of varying sizes, depending on the values of their parameters, using a technique called recursion. To illustrate this, the following is a small, ®xed-size procedure for making paper chains that can still make chains of arbitrary lengthÐ it has a parameter n for the desired length. You'll need a bunch of long, thin strips of paper and some way of joining the ends of a strip to make a loop. You can use tape, a stapler, or if you use slitted strips of cardstock that look like this , you can just slip the slits together.
    [Show full text]
  • A Category-Theoretic Approach to Representation and Analysis of Inconsistency in Graph-Based Viewpoints
    A Category-Theoretic Approach to Representation and Analysis of Inconsistency in Graph-Based Viewpoints by Mehrdad Sabetzadeh A thesis submitted in conformity with the requirements for the degree of Master of Science Graduate Department of Computer Science University of Toronto Copyright c 2003 by Mehrdad Sabetzadeh Abstract A Category-Theoretic Approach to Representation and Analysis of Inconsistency in Graph-Based Viewpoints Mehrdad Sabetzadeh Master of Science Graduate Department of Computer Science University of Toronto 2003 Eliciting the requirements for a proposed system typically involves different stakeholders with different expertise, responsibilities, and perspectives. This may result in inconsis- tencies between the descriptions provided by stakeholders. Viewpoints-based approaches have been proposed as a way to manage incomplete and inconsistent models gathered from multiple sources. In this thesis, we propose a category-theoretic framework for the analysis of fuzzy viewpoints. Informally, a fuzzy viewpoint is a graph in which the elements of a lattice are used to specify the amount of knowledge available about the details of nodes and edges. By defining an appropriate notion of morphism between fuzzy viewpoints, we construct categories of fuzzy viewpoints and prove that these categories are (finitely) cocomplete. We then show how colimits can be employed to merge the viewpoints and detect the inconsistencies that arise independent of any particular choice of viewpoint semantics. Taking advantage of the same category-theoretic techniques used in defining fuzzy viewpoints, we will also introduce a more general graph-based formalism that may find applications in other contexts. ii To my mother and father with love and gratitude. Acknowledgements First of all, I wish to thank my supervisor Steve Easterbrook for his guidance, support, and patience.
    [Show full text]
  • Knowledge Representation in Bicategories of Relations
    Knowledge Representation in Bicategories of Relations Evan Patterson Department of Statistics, Stanford University Abstract We introduce the relational ontology log, or relational olog, a knowledge representation system based on the category of sets and relations. It is inspired by Spivak and Kent’s olog, a recent categorical framework for knowledge representation. Relational ologs interpolate between ologs and description logic, the dominant formalism for knowledge representation today. In this paper, we investigate relational ologs both for their own sake and to gain insight into the relationship between the algebraic and logical approaches to knowledge representation. On a practical level, we show by example that relational ologs have a friendly and intuitive—yet fully precise—graphical syntax, derived from the string diagrams of monoidal categories. We explain several other useful features of relational ologs not possessed by most description logics, such as a type system and a rich, flexible notion of instance data. In a more theoretical vein, we draw on categorical logic to show how relational ologs can be translated to and from logical theories in a fragment of first-order logic. Although we make extensive use of categorical language, this paper is designed to be self-contained and has considerable expository content. The only prerequisites are knowledge of first-order logic and the rudiments of category theory. 1. Introduction arXiv:1706.00526v2 [cs.AI] 1 Nov 2017 The representation of human knowledge in computable form is among the oldest and most fundamental problems of artificial intelligence. Several recent trends are stimulating continued research in the field of knowledge representation (KR).
    [Show full text]
  • An Introduction to Category Theory and Categorical Logic
    An Introduction to Category Theory and Categorical Logic Wolfgang Jeltsch Category theory An Introduction to Category Theory basics Products, coproducts, and and Categorical Logic exponentials Categorical logic Functors and Wolfgang Jeltsch natural transformations Monoidal TTU¨ K¨uberneetika Instituut categories and monoidal functors Monads and Teooriaseminar comonads April 19 and 26, 2012 References An Introduction to Category Theory and Categorical Logic Category theory basics Wolfgang Jeltsch Category theory Products, coproducts, and exponentials basics Products, coproducts, and Categorical logic exponentials Categorical logic Functors and Functors and natural transformations natural transformations Monoidal categories and Monoidal categories and monoidal functors monoidal functors Monads and comonads Monads and comonads References References An Introduction to Category Theory and Categorical Logic Category theory basics Wolfgang Jeltsch Category theory Products, coproducts, and exponentials basics Products, coproducts, and Categorical logic exponentials Categorical logic Functors and Functors and natural transformations natural transformations Monoidal categories and Monoidal categories and monoidal functors monoidal functors Monads and Monads and comonads comonads References References An Introduction to From set theory to universal algebra Category Theory and Categorical Logic Wolfgang Jeltsch I classical set theory (for example, Zermelo{Fraenkel): I sets Category theory basics I functions from sets to sets Products, I composition
    [Show full text]
  • Multi-Level Constraints
    Multi-Level Constraints Tony Clark1 and Ulrich Frank2 1 Aston University, UK, [email protected] 2 University of Duisburg-Essen, DE, [email protected] Abstract. Meta-modelling and domain-specific modelling languages are supported by multi-level modelling which liberates model-based engi- neering from the traditional two-level type-instance language architec- ture. Proponents of this approach claim that multi-level modelling in- creases the quality of the resulting systems by introducing a second ab- straction dimension and thereby allowing both intra-level abstraction via sub-typing and inter-level abstraction via meta-types. Modelling ap- proaches include constraint languages that are used to express model semantics. Traditional languages, such as OCL, support intra-level con- straints, but not inter-level constraints. This paper motivates the need for multi-level constraints, shows how to implement such a language in a reflexive language architecture and applies multi-level constraints to an example multi-level model. 1 Introduction Conceptual models aim to bridge the gap between natural languages that are required to design and use a system and implementation languages. To this end, general-purpose modelling languages (GPML) like the UML consist of concepts that represent semantic primitives such as class, attribute, etc., that, on the one hand correspond to concepts of foundational ontologies, e.g., [4], and on the other hand can be nicely mapped to corresponding elements of object-oriented programming languages. Since GPML can be used to model a wide range of systems, they promise at- tractive economies of scale. At the same time, their use suffers from the fact that they offer generic concepts only.
    [Show full text]
  • Union Types for Semistructured Data
    Edinburgh Research Explorer Union Types for Semistructured Data Citation for published version: Buneman, P & Pierce, B 1999, Union Types for Semistructured Data. in Union Types for Semistructured Data: 7th International Workshop on Database Programming Languages, DBPL’99 Kinloch Rannoch, UK, September 1–3,1999 Revised Papers. Lecture Notes in Computer Science, vol. 1949, Springer-Verlag GmbH, pp. 184-207. https://doi.org/10.1007/3-540-44543-9_12 Digital Object Identifier (DOI): 10.1007/3-540-44543-9_12 Link: Link to publication record in Edinburgh Research Explorer Document Version: Peer reviewed version Published In: Union Types for Semistructured Data General rights Copyright for the publications made accessible via the Edinburgh Research Explorer is retained by the author(s) and / or other copyright owners and it is a condition of accessing these publications that users recognise and abide by the legal requirements associated with these rights. Take down policy The University of Edinburgh has made every reasonable effort to ensure that Edinburgh Research Explorer content complies with UK legislation. If you believe that the public display of this file breaches copyright please contact [email protected] providing details, and we will remove access to the work immediately and investigate your claim. Download date: 27. Sep. 2021 Union Typ es for Semistructured Data Peter Buneman Benjamin Pierce University of Pennsylvania Dept of Computer Information Science South rd Street Philadelphia PA USA fpeterbcpiercegcisupenn edu Technical
    [Show full text]
  • Arxiv:1811.04966V3 [Math.NT]
    Descartes’ rule of signs, Newton polygons, and polynomials over hyperfields Matthew Baker and Oliver Lorscheid Abstract. In this note, we develop a theory of multiplicities of roots for polynomials over hyperfields and use this to provide a unified and conceptual proof of both Descartes’ rule of signs and Newton’s “polygon rule”. Introduction Given a real polynomial p ∈ R[T ], Descartes’ rule of signs provides an upper bound for the number of positive (resp. negative) real roots of p in terms of the signs of the coeffi- cients of p. Specifically, the number of positive real roots of p (counting multiplicities) is bounded above by the number of sign changes in the coefficients of p(T ), and the number of negative roots is bounded above by the number of sign changes in the coefficients of p(−T ). Another classical “rule”, which is less well known to mathematicians in general but is used quite often in number theory, is Newton’s polygon rule. This rule concerns polynomi- als over fields equipped with a valuation, which is a function v : K → R ∪{∞} satisfying • v(a) = ∞ if and only if a = 0 • v(ab) = v(a) + v(b) • v(a + b) > min{v(a),v(b)}, with equality if v(a) 6= v(b) for all a,b ∈ K. An example is the p-adic valuation vp on Q, where p is a prime number, given by the formula vp(s/t) = ordp(s) − ordp(t), where ordp(n) is the maximum power of p dividing a nonzero integer n. Another example is the T -adic valuation v on k(T), for any field k, given by v ( f /g) = arXiv:1811.04966v3 [math.NT] 26 May 2020 T T ordT ( f )−ordT (g), where ordT ( f ) is the maximum power of T dividing a nonzero polyno- mial f ∈ k[T].
    [Show full text]
  • Diagrammatics in Categorification and Compositionality
    Diagrammatics in Categorification and Compositionality by Dmitry Vagner Department of Mathematics Duke University Date: Approved: Ezra Miller, Supervisor Lenhard Ng Sayan Mukherjee Paul Bendich Dissertation submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in the Department of Mathematics in the Graduate School of Duke University 2019 ABSTRACT Diagrammatics in Categorification and Compositionality by Dmitry Vagner Department of Mathematics Duke University Date: Approved: Ezra Miller, Supervisor Lenhard Ng Sayan Mukherjee Paul Bendich An abstract of a dissertation submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy in the Department of Mathematics in the Graduate School of Duke University 2019 Copyright c 2019 by Dmitry Vagner All rights reserved Abstract In the present work, I explore the theme of diagrammatics and their capacity to shed insight on two trends|categorification and compositionality|in and around contemporary category theory. The work begins with an introduction of these meta- phenomena in the context of elementary sets and maps. Towards generalizing their study to more complicated domains, we provide a self-contained treatment|from a pedagogically novel perspective that introduces almost all concepts via diagrammatic language|of the categorical machinery with which we may express the broader no- tions found in the sequel. The work then branches into two seemingly unrelated disciplines: dynamical systems and knot theory. In particular, the former research defines what it means to compose dynamical systems in a manner analogous to how one composes simple maps. The latter work concerns the categorification of the slN link invariant. In particular, we use a virtual filtration to give a more diagrammatic reconstruction of Khovanov-Rozansky homology via a smooth TQFT.
    [Show full text]
  • Kleisli Database Instances
    KLEISLI DATABASE INSTANCES DAVID I. SPIVAK Abstract. We use monads to relax the atomicity requirement for data in a database. Depending on the choice of monad, the database fields may contain generalized values such as lists or sets of values, or they may contain excep- tions such as various typesi of nulls. The return operation for monads ensures that any ordinary database instance will count as one of these generalized in- stances, and the bind operation ensures that generalized values behave well under joins of foreign key sequences. Different monads allow for vastly differ- ent types of information to be stored in the database. For example, we show that classical concepts like Markov chains, graphs, and finite state automata are each perfectly captured by a different monad on the same schema. Contents 1. Introduction1 2. Background3 3. Kleisli instances9 4. Examples 12 5. Transformations 20 6. Future work 22 References 22 1. Introduction Monads are category-theoretic constructs with wide-ranging applications in both mathematics and computer science. In [Mog], Moggi showed how to exploit their expressive capacity to incorporate fundamental programming concepts into purely functional languages, thus considerably extending the potency of the functional paradigm. Using monads, concepts that had been elusive to functional program- ming, such as state, input/output, and concurrency, were suddenly made available in that context. In the present paper we describe a parallel use of monads in databases. This approach stems from a similarity between categories and database schemas, as presented in [Sp1]. The rough idea is as follows. A database schema can be modeled as a category C, and an ordinary database instance is a functor δ : C Ñ Set.
    [Show full text]
  • Djangoshop Release 0.11.2
    djangoSHOP Release 0.11.2 Oct 27, 2017 Contents 1 Software Architecture 1 2 Unique Features of django-SHOP5 3 Upgrading 7 4 Tutorial 9 5 Reference 33 6 How To’s 125 7 Development and Community 131 8 To be written 149 9 License 155 Python Module Index 157 i ii CHAPTER 1 Software Architecture The django-SHOP framework is, as its name implies, a framework and not a software which runs out of the box. Instead, an e-commerce site built upon django-SHOP, always consists of this framework, a bunch of other Django apps and the merchant’s own implementation. While this may seem more complicate than a ready-to-use solution, it gives the programmer enormous advantages during the implementation: Not everything can be “explained” to a software system using graphical user interfaces. After reaching a certain point of complexity, it normally is easier to pour those requirements into executable code, rather than to expect yet another set of configuration buttons. When evaluating django-SHOP with other e-commerce solutions, I therefore suggest to do the following litmus test: Consider a product which shall be sold world-wide. Depending on the country’s origin of the request, use the native language and the local currency. Due to export restrictions, some products can not be sold everywhere. Moreover, in some countries the value added tax is part of the product’s price, and must be stated separately on the invoice, while in other countries, products are advertised using net prices, and tax is added later on the invoice.
    [Show full text]