DOCSLIB.ORG

Lecture P5: Abstract Data Types Data Type

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Lecture P5: Abstract Data Types Data Type Overview Lecture P5: Abstract Data Types Data type: ■ Set of values and collection of operations on those values. ■ Ex. short int – set of values between -32,768 and 32,767 – arithmetic operations: + - * / % Abstract data type (ADT): ■ Data type whose representation is HIDDEN. ■ Don’t want client to directly manipulate data type. ■ Operations ONLY permitted through interface. Separate implementation from specification. ■ INTERFACE: specify the allowed operations ■ IMPLEMENTATION: provide code for operations ■ CLIENT: code that uses operations 1/27/00 Copyright © 2000, Kevin Wayne P5.1 1/27/00 Copyright © 2000, Kevin Wayne P5.2 Advantages of ADT’s Complex Number Data Type Different clients can share the same ADT. Create data structure to represent complex numbers. ■ See Sedgewick 4.8. Can change ADT without changing clients. ■ Store in rectangular form: real and imaginary parts. Client doesn’t (need to) know how implementation works. typedef struct { Convenient way to organize large problems. double re; ■ Decompose into smaller problems. double im; ■ Substitute alternate solutions. } Complex; ■ Separation compilation. ■ Build libraries. Powerful mechanism for building layers of abstraction. ■ Client works at a higher level of abstraction. 1/27/00 Copyright © 2000, Kevin Wayne P5.3 1/27/00 Copyright © 2000, Kevin Wayne P5.4 Complex Number Data Type: Interface Complex Number Data Type: Client Interface lists allowable operations on complex data type. Client program uses interface operations to calculate something: COMPLEX.h client.c typedef struct { #include <stdio.h> double re; #include “COMPLEX.h” client can use interface double im; interface goes in .h file } Complex; int main(void) { Complex COMPLEXadd (Complex, Complex); . your favorite application Complex COMPLEXmult (Complex, Complex); . that uses complex numbers Complex COMPLEXpow (Complex, int); Complex COMPLEXconj (Complex); return 0; double COMPLEXmod (Complex); } double COMPLEXreal (Complex); double COMPLEXimag (Complex); Complex COMPLEXinit (double, double); void COMPLEXprint(Complex); 1/27/00 Copyright © 2000, Kevin Wayne P5.5 1/27/00 Copyright © 2000, Kevin Wayne P5.6 Complex Number Data Type: Implementation Complex Number Data Type: Implementation Write code for interface functions. Write code for interface functions. complex.c complex.c (cont) #include “COMPLEX.h” implementation needs to double COMPLEXmod(Complex a) { know interface return sqrt(a.re * a.re + a.im * a.im); } Complex COMPLEXadd (Complex a, Complex b) { Complex t; void COMPLEXprint(Complex) { t.re = a.re + b.re; printf(“%f + %f i\n”, a.re, a.im); t.im = a.im + b.im; } return t; } Complex COMPLEXinit(double x, double y) { Complex t; Complex COMPLEXmult(Complex a, Complex b) { t.re = x; Complex t; t.im = y; t.re = a.re * b.re - a.im * b.im; return t; t.im = a.re * b.im + a.im * b.re; } return t; } 1/27/00 Copyright © 2000, Kevin Wayne P5.7 1/27/00 Copyright © 2000, Kevin Wayne P5.8 Separate Compilation Can Change Implementation Client and implementation both include COMPLEX.h Can use alternate representation of complex numbers. ■ Store in polar form: modulus and angle. Can be compiled jointly. %gcc client.c complex.c z = x + i y = r ( cos θ + i sin θ ) = r ei θ Can be compiled separately. %gcc -c complex.c %gcc -c client.c %gcc client.o complex.o typedef struct { double r; double theta; } Complex; 1/27/00 Copyright © 2000, Kevin Wayne P5.9 1/27/00 Copyright © 2000, Kevin Wayne P5.10 Alternate Interface Alternate Implementation Interface lists allowable operations on complex data type. Write code for interface functions. COMPLEX.h complex.c typedef struct { #include “COMPLEX.h” double r; double theta; Complex COMPLEXmod(Complex a) { } Complex; return a.r; } Complex COMPLEXadd (Complex, Complex); Complex COMPLEXmult (Complex, Complex); Complex COMPLEXmult(Complex a, Complex b) { Complex COMPLEXpow (Complex, int); Complex t; Complex COMPLEXconj (Complex); t.modulus = a.r * b.r; double COMPLEXmod (Complex); t.angle = a.theta + b.theta; double COMPLEXreal (Complex); } double COMPLEXimag (Complex); Complex COMPLEXinit (double, double); Some interface functions are void COMPLEXprint(Complex); now much easier to code up. 1/27/00 Copyright © 2000, Kevin Wayne P5.11 1/27/00 Copyright © 2000, Kevin Wayne P5.12 Alternate Implementation Multiple Implementations Write code for interface functions. Usually, there are several ways to represent and implement a data type. complex.c Which is better: rectangular or polar representation of Complex numbers? ■ Depends on application. #include <math.h> ■ Rectangular are better for additions and subtractions. Complex COMPLEXadd(Complex a, Complex b) { – no need to evaluate arctangent function Complex t; ■ Polar are better for multiply and modulus. double x, y; x = a.r * cos(a.theta) + b.r * cos(b.theta); – no need to take square roots y = a.r * sin(a.theta) + b.r * sin(b.theta); ■ Get used to making tradeoffs. t.r = sqrt(x*x + y*y); t.theta = arctan(y/x); This example may seem artificial. return t; } ■ Essential for many real applications. Others are more annoying. 1/27/00 Copyright © 2000, Kevin Wayne P5.13 1/27/00 Copyright © 2000, Kevin Wayne P5.14 Rational Number Data Type “Non ADT’s” See Assignment 3. Is Complex data type an ABSTRACT data type? ■ You will create data type for Rational numbers. ■ NO: Representation in interface. ■ Add associated operations (add, multiply, reduce) to Rational number – Client can directly manipulate the data type: a.re = 5.0; data type. ■ Difficult to hide representation with user-defined sets of values. ■ Possible to fix (see Sedgewick 4.8 or COS 217). typedef struct { int p; /* numerator */ Are C built-in types like int ADT’s? int q; /* denominator */ ■ ALMOST: we generally ignore representation. } Rational; ■ NO: set of values depends on representation. – might use (x & 1) to test if odd – works only if they’re stored as two’s complement integers ■ CONSEQUENCE: strive to write programs that function properly independent of representation. – (x % 2) is portable way to test if odd – also, use <limits.h> for machine-specific ranges of int, long 1/27/00 Copyright © 2000, Kevin Wayne P5.15 1/27/00 Copyright © 2000, Kevin Wayne P5.16 ADT’s for Stacks and Queues Stack Interface and Client Prototypical data type. void STACKinit(void); ■ Set of operations (insert, delete) on generic data. int STACKempty(void); STACK of integers void STACKpush(int); Stack (“last in first out” or LIFO) int STACKpop(void); ■ push: add info to the data structure ■ pop: remove the info MOST recently added STACK.h #include “STACK.h” ■ initialize, test if empty int main(void) { int a, b; Queue (“first in first out” or FIFO) . ■ put: add info to the data structure STACKinit(); client uses data type, without STACKpush(a); ■ get: remove the info LEAST recently added regard to how it is represented . ■ initialize, test if empty or implemented. b = STACKpop(); return 0; Could use EITHER array or linked list see Lecture P7 } to implement EITHER stack or queue. client.c 1/27/00 Copyright © 2000, Kevin Wayne P5.17 1/27/00 Copyright © 2000, Kevin Wayne P5.18 Stack Implementation with Arrays Compilation Push and pop at the end of array. Client and implementation both include STACK.h #include <stdlib.h> #include “STACK.h” Demo: Can be compiled jointly. int s[1000]; int N; %gcc client.c stackarray.c Drawback: void STACKinit(void) { ! Have to reserve space for N = 0; Can be compiled separately. max size. } %gcc -c stackarray.c int STACKempty(void) { %gcc -c client.c return N == 0; %gcc client.o stackarray.o } void STACKpush(int item) { s[N++] = item; } int STACKpop(void) { return s[--N]; } stackarray.c 1/27/00 Copyright © 2000, Kevin Wayne P5.19 1/27/00 Copyright © 2000, Kevin Wayne P5.20 Balanced Parentheses Balanced Parentheses parentheses.c parentheses.c (cont) int balanced(char a[]) { #include <stdio.h> int i; #include "STACK.h" STACKinit(); #define NMAX 1000 for (i = 0; a[i] != '\0'; i++) { push all left if (a[i] == '(') int main(void) { Read from stdin, ignoring parentheses STACKpush(a[i]); int c, i = 0; non-parentheses else if (a[i] == ')') { char a[NMAX]; if (STACKempty()) return 0; check for matching if (STACKpop() != '(') return 0; while ((c = getchar()) != EOF)) left parenthesis } if (c == '(' || c == ')’) } a[i++] = c; balanced if stack is empty return STACKempty(); a[i] = '\0'; when no more input } if (balanced(a)) printf("balanced\n"); check if balanced else printf("unbalanced\n"); return 0; ( ( ( ) ( ) ) ) Good: } Bad: ( ( ) ) ) ( ( ) 1/27/00 Copyright © 2000, Kevin Wayne P5.21 1/27/00 Copyright © 2000, Kevin Wayne P5.22 Balanced Parentheses ADT Review Check if your C program has unbalanced parentheses. Client can access data type ONLY through implementation. ■ Example: STACK implementation. Unix % gcc parentheses.c stackarray.c Representation is HIDDEN in the implementation. % a.out < myprog.c ■ Implementation uses arrays. % balanced ■ Client is completely unaware of this. % % a.out < parentheses.c % unbalanced Can change ADT without changing clients at all. ■ In Lecture P7 we implement stack using linked lists instead of arrays. How could valid C program have ■ Obtain different time / space tradeoffs. unbalanced parentheses? Exercise: extend to handle square and curly braces. ■ Good: { ( [ ( [ ] ) ( ) ] ) } ■ Bad: ( ( [ ) ] ) 1/27/00 Copyright © 2000, Kevin Wayne P5.23 1/27/00 Copyright © 2000, Kevin Wayne P5.24 First Class ADT Reverse Polish (Postfix) Notation So far, only 1 stack or queue per program. STACKinit(); Practical example of use of stack abstraction. STACKpush(a); Put operator after operands in expression. ■ Use stack to evaluate. b = STACKpop(); – operand: push it onto stack. – operator: pop operands, push result. First Class ADT: ■ Systematic way to save intermediate results. ■ ADT that is just like a built-in C type. Stack s1, s2; ■ Can declare multiple instances of them. Example 1. s1 = STACKinit(); ■ Pass specific instances of them to ■ 1 2 3 4 5 * + 6 * * 7 8 9 + + * + interface as inputs. s2 = STACKinit(); . ■ Details omitted in COS 126 - see STACKpush(s1, a); Sedgewick 4.8 or COS 226 if interested.
Load more

Recommended publications
  • Datatypes (Pdf Format)
    Basic Scripting, Syntax, and Data Types in Python Mteor 227 – Fall 2020 Basic Shell Scripting/Programming with Python • Shell: a user interface for access to an operating system’s services. – The outer layer between the user and the operating system. • The first line in your program needs to be: #!/usr/bin/python • This line tells the computer what python interpreter to use. Comments • Comments in Python are indicated with a pound sign, #. • Any text following a # and the end of the line is ignored by the interpreter. • For multiple-line comments, a # must be used at the beginning of each line. Continuation Line • The \ character at the end of a line of Python code signifies that the next line is a continuation of the current line. Variable Names and Assignments • Valid characters for variable, function, module, and object names are any letter or number. The underscore character can also be used. • Numbers cannot be used as the first character. • The underscore should not be used as either the first or last character, unless you know what you are doing. – There are special rules concerning leading and trailing underscore characters. Variable Names and Assignments • Python is case sensitive! Capitalization matters. – The variable f is not the same as the variable F. • Python supports parallel assignment >>> a, b = 5, 'hi' >>> a 5 >>> b 'hi' Data Types • Examples of data types are integers, floating-point numbers, complex numbers, strings, etc. • Python uses dynamic typing, which means that the variable type is determined by its input. – The same variable name can be used as an integer at one point, and then if a string is assigned to it, it then becomes a string or character variable.
    [Show full text]
  • MPLAB C Compiler for PIC24 Mcus and Dspic Dscs User's Guide
    MPLAB® C Compiler for PIC24 MCUs and dsPIC® DSCs User’s Guide 2002-2011 Microchip Technology Inc. DS51284K Note the following details of the code protection feature on Microchip devices: • Microchip products meet the specification contained in their particular Microchip Data Sheet. • Microchip believes that its family of products is one of the most secure families of its kind on the market today, when used in the intended manner and under normal conditions. • There are dishonest and possibly illegal methods used to breach the code protection feature. All of these methods, to our knowledge, require using the Microchip products in a manner outside the operating specifications contained in Microchip’s Data Sheets. Most likely, the person doing so is engaged in theft of intellectual property. • Microchip is willing to work with the customer who is concerned about the integrity of their code. • Neither Microchip nor any other semiconductor manufacturer can guarantee the security of their code. Code protection does not mean that we are guaranteeing the product as “unbreakable.” Code protection is constantly evolving. We at Microchip are committed to continuously improving the code protection features of our products. Attempts to break Microchip’s code protection feature may be a violation of the Digital Millennium Copyright Act. If such acts allow unauthorized access to your software or other copyrighted work, you may have a right to sue for relief under that Act. Information contained in this publication regarding device Trademarks applications and the like is provided only for your convenience The Microchip name and logo, the Microchip logo, dsPIC, and may be superseded by updates.
    [Show full text]
  • Software II: Principles of Programming Languages
    Software II: Principles of Programming Languages Lecture 6 – Data Types Some Basic Definitions • A data type defines a collection of data objects and a set of predefined operations on those objects • A descriptor is the collection of the attributes of a variable • An object represents an instance of a user- defined (abstract data) type • One design issue for all data types: What operations are defined and how are they specified? Primitive Data Types • Almost all programming languages provide a set of primitive data types • Primitive data types: Those not defined in terms of other data types • Some primitive data types are merely reflections of the hardware • Others require only a little non-hardware support for their implementation The Integer Data Type • Almost always an exact reflection of the hardware so the mapping is trivial • There may be as many as eight different integer types in a language • Java’s signed integer sizes: byte , short , int , long The Floating Point Data Type • Model real numbers, but only as approximations • Languages for scientific use support at least two floating-point types (e.g., float and double ; sometimes more • Usually exactly like the hardware, but not always • IEEE Floating-Point Standard 754 Complex Data Type • Some languages support a complex type, e.g., C99, Fortran, and Python • Each value consists of two floats, the real part and the imaginary part • Literal form real component – (in Fortran: (7, 3) imaginary – (in Python): (7 + 3j) component The Decimal Data Type • For business applications (money)
    [Show full text]
  • Vivado Design Suite User Guide: High-Level Synthesis (UG902)
    Vivado Design Suite User Guide High-Level Synthesis UG902 (v2018.3) December 20, 2018 Revision History Revision History The following table shows the revision history for this document. Section Revision Summary 12/20/2018 Version 2018.3 Schedule Viewer Updated information on the schedule viewer. Optimizing the Design Clarified information on dataflow and loops throughout section. C++ Arbitrary Precision Fixed-Point Types: Reference Added note on using header files. Information HLS Math Library Updated information on how hls_math.h is used. The HLS Math Library, Fixed-Point Math Functions Updated functions. HLS Video Library, HLS Video Functions Library Moved the HLS video library to the Xilinx GitHub (https:// github.com/Xilinx/xfopencv) HLS SQL Library, HLS SQL Library Functions Updated hls::db to hls::alg functions. System Calls Added information on using the __SYNTHESIS__ macro. Arrays Added information on array sizing behavior. Command Reference Updated commands. config_dataflow, config_rtl Added the option -disable_start_propagation Class Methods, Operators, and Data Members Added guidance on specifying data width. UG902 (v2018.3) December 20, 2018Send Feedback www.xilinx.com High-Level Synthesis 2 Table of Contents Revision History...............................................................................................................2 Chapter 1: High-Level Synthesis............................................................................ 5 High-Level Synthesis Benefits....................................................................................................5
    [Show full text]
  • Should C Replace FORTRAN As the Language of Scientific Programming?
    Should C Replace FORTRAN as the Language of Scientific Programming? Linda Wharton CSCI 5535 Fall 1995 Abstract Anti-FORTRAN sentiment has recently become more prevalent. Where does the attitude originate? The most probable source is academia, where C and C++ are the languages of choice. Is there a fact based justification for the attitude? FORTRAN and C are evaluated to determine whether C is a better language than FORTRAN for scientific programming. The features of FORTRAN 77, FORTRAN 90, C and C++ are compared, and evaluated as to how well they meet the requirements of the scientific programming domain. FORTRAN was designed specifically for numerical programming, and thus better meets the requirements. Three algorithms in the scientific domain are coded in both FORTRAN and C. They are evaluated on performance, readability of the code and optimization potential. In all cases the FORTRAN implementations proved superior. Is there evidence to mandate that all upgrades and new development should be done in C, rather than FORTRAN? A good computer programmer can solve any given problem in any language, however it is best to code in the language specifically designed for the problem domain. In the case of scientific programming, that language is FORTRAN. 1 Introduction In the computer arena related to scientific programming, a prevalent attitude seems to be that FORTRAN is obsolete, and C should be used as a replacement language. I am employed as a programmer that supports meteorological research. Most of the programming code I work with is written in FORTRAN. Within the course of my work, I continually encounter prejudice against FORTRAN.
    [Show full text]
  • Stable/Src/Hdmf
    HD HierarchicalM DataF Modeling Framework HDMF Release 3.1.1 Aug 13, 2021 Getting Started 1 Installing HDMF 3 1.1 Option 1: Using pip...........................................3 1.2 Option 2: Using conda..........................................3 2 Tutorials 5 2.1 DynamicTable Tutorial..........................................5 2.2 MultiContainerInterface.........................................9 2.3 AlignedDynamicTable.......................................... 13 2.4 ExternalResources............................................ 19 2.5 DynamicTable How-To Guide...................................... 24 3 Introduction 39 4 Software Architecture 41 4.1 Main Concepts.............................................. 44 4.2 Additional Concepts........................................... 46 5 Citing HDMF 49 5.1 BibTeX entry............................................... 49 5.2 Using RRID............................................... 49 5.3 Using duecredit.............................................. 49 6 API Documentation 51 6.1 hdmf.common package.......................................... 51 6.2 hdmf.container module.......................................... 73 6.3 hdmf.build package........................................... 76 6.4 hdmf.spec package............................................ 91 6.5 hdmf.backends package......................................... 108 6.6 hdmf.data_utils module......................................... 120 6.7 hdmf.utils module............................................ 124 6.8 hdmf.validate package.........................................
    [Show full text]
  • Fundamental Programming Concepts
    APPENDIX A Fundamental Programming Concepts The following information is for readers who are new to programming and need a primer on some fundamental programming concepts. If you have programmed in another language, chances are the concepts presented in this appendix are not new to you. You should, however, review the material briefly to become familiar with the C# syntax. Working with Variables and Data Types Variables in programming languages store values that can change while the program executes. For example, if you wanted to count the number of times a user tries to log in to an application, you could use a variable to track the number of attempts. A variable is a memory location where a value is stored. Using the variable, your program can read or alter the value stored in memory. Before you use a variable in your program, however, you must declare it. When you declare a variable, the compiler also needs to know what kind of data will be stored at the memory location. For example, will it be numbers or letters? If the variable will store numbers, how large can a number be? Will the variable store decimals or only whole numbers? You answer these questions by assigning a data type to the variable. A login counter, for example, only needs to hold positive whole numbers. The following code demonstrates how you declare a variable named counter in C# with an integer data type: int counter; Specifying the data type is referred to as strong typing. Strong typing results in more efficient memory management, faster execution, and compiler type checking, all of which reduces runtime errors.
    [Show full text]
  • Lecture 5: File I/O, Advanced Unix, Enum/Struct/Union, Subtyping
    CIS 507: _ _ _ _ ______ _ _____ / / / /___ (_) __ ____ _____ ____/ / / ____/ _/_/ ____/__ __ / / / / __ \/ / |/_/ / __ `/ __ \/ __ / / / _/_// / __/ /___/ /_ / /_/ / / / / /> < / /_/ / / / / /_/ / / /____/_/ / /__/_ __/_ __/ \____/_/ /_/_/_/|_| \__,_/_/ /_/\__,_/ \____/_/ \____//_/ /_/ ! Lecture 5: File I/O, Advanced Unix, Enum/Struct/Union, Subtyping Oct. 23rd, 2018 Hank Childs, University of Oregon Project 3 • Time to get going on Project 3 • It is about 1000 lines of code File I/O File I/O: streams and file descriptors • Two ways to access files: – File descriptors: • Lower level interface to files and devices – Provides controls to specific devices • Type: small integers (typically 20 total) – Streams: • HigHer level interface to files and devices – Provides uniform interface; easy to deal with, but less powerful • Type: FILE * Streams are more portable, and more accessible to beginning programmers. (I teacH streams Here.) File I/O • Process for reading or wriNng – Open a file • Tells Unix you intend to do file I/O • FuncNon returns a “FILE * – Used to idenNfy the file from this point forward • CHecks to see if permissions are valid – Read from the file / write to the file – Close the file Opening a file • FILE *handle = fopen(filename, mode); Example: FILE *h = fopen(“/tmp/330”, “wb”); Close wHen you are done with “fclose” Note: #include <stdio.H> Reading / WriNng Example File PosiNon Indicator • File posiNon indicator: the current locaon in the file • If I read one byte, the one byte you get is wHere the file posiNon indicator is poinNng.
    [Show full text]
  • SDK Development for Bridging Heterogeneous Data Sources Through Connect Bridge Platform
    PM SDK Development for Bridging Heterogeneous Data Sources Through Connect Bridge Platform MASTER PROJECT Filipa José Faria Nóbrega MASTER IN COMPUTER ENGINEERING September | 2018 SDK Development for Bridging Heterogenous Data Sources Through Connect Bridge Platform MASTER PROJECT Filipa José Faria Nóbrega MASTER IN COMPUTER ENGINEERING SUPERVISOR Leonel Domingos Telo Nóbrega CO-SUPERVISOR Stanislav Pernecký This page intentionally left blank i DEDICATION AND ACKNOWLEDGEMENTS irst of all, my deep sense of gratitude goes to all the extraordinary people who have F been generous enough to dedicate some of their time and knowledge during the course of my dissertation work. The attitude of the people made this dissertation possible. I am extremely thankful to my supervisor Prof. Dr. Leonel Nóbrega for his guidance, constant encouragement, valuable suggestions and critical discussions throughout my dissertation work. During my dissertation-writing period, he provided encouragement, good teaching, sound advice, and many good ideas. I also thank him for his patience and kindness. His dedication to work and perfectionism will have a far-reaching impact on my life, academic and beyond. I would also like to thank my supervisor Eng. Stanislav Pernecký for his guidance, inspiring suggestions and critical discussions throughout my dissertation work. I am especially grateful to Connecting Software for creating excellent working conditions and providing financial support. My heartfelt thanks to my friends for providing me with unfailing support and continuous encouragement. Special thanks to all participants who spend their time to contribute to the outcome of this dissertation. I would also like to thank Max for his love, support, humour, and energy that has given me strength in life.
    [Show full text]
  • 8.5 Java Ronald F
    “handbook” i i 2005/2/4 page 160 i i 160 Chapter 8. General methods for implementing reliable and correct software 8.5 Java Ronald F. Boisvert and Roldan Pozo 51 8.5.1 Introduction The Java52 programming language and environment have become extremely popular since their introduction in the mid 1990s. Indeed, some claim that the number of Java program- mers will soon exceed those who use C/C++. Java was not designed for numerical com- puting, and few scientific applications exist in pure Java as of this writing. Nevertheless, Java has a number of features that make it quite desirable if one’s goal is the development of highly reliable software. Among these are the portability provided by the Java Vir- tual Machine (JVM) and language features that promote safety. In addition, Java provides an object-oriented development framework, a network-aware environment, and access to a rich base of system utilities that make the development of complete applications quite convenient. Such features make it an attractive alternative to Fortran, C, or C++ for the development of scientific applications. Our goal here is to provide some guidance to non-Java programmers as to whether Java might be appropriate for scientific applications. We will discuss some of Java’s fea- tures which promote the safety, reliability, and portability, and then briefly address the biggest concern of most scientific users: performance. We conclude with a short discus- sion of some deficiencies of Java in the context of scientific computing. 8.5.2 Language Features While Java’s first applications were related to the development of embedded systems, the language itself is a general-purpose programming language [Gosling et al., 2000].
    [Show full text]
  • Abstract Data Types and Modules
    Programming Languages Third Edition Chapter 11 Abstract Data Types and Modules Objectives • Understand the algebraic specification of abstract data types • Be familiar with abstract data type mechanisms and modules • Understand separate compilation in C, C++ namespaces, and Java packages • Be familiar with Ada packages • Be familiar with modules in ML Programming Languages, Third Edition 2 1 Objectives (cont’d.) • Learn about modules in earlier languages • Understand problems with abstract data type mechanisms • Be familiar with the mathematics of abstract data types Programming Languages, Third Edition 3 Introduction • Data type: a set of values, along with certain operations on those values • Two kinds of data types: predefined and user- defined • Predefined data types: – Insulate the user from the implementation, which is machine dependent – Manipulated by a set of predefined operations – Use is completely specified by predetermined semantics Programming Languages, Third Edition 4 2 Introduction (cont’d.) • User-defined data types: – Built from data structures using language's built-in data types and type constructors – Internal organization is visible to the user – No predefined operations • Would be desirable to have a mechanism for constructing data types with as many characteristics of a built-in type as possible • Abstract data type (or ADT): a data type for constructing user-defined data types Programming Languages, Third Edition 5 Introduction (cont’d.) • Important design goals for data types include modifiability, reusability,
    [Show full text]
  • Type-Indexed Data Types
    Type-indexed data types Ralf Hinze1;2, Johan Jeuring2;3, and Andres L¨oh2 1 Institut f¨urInformatik III, Universit¨atBonn R¨omerstraße164, 53117 Bonn, Germany [email protected] http://www.informatik.uni-bonn.de/~ralf/ 2 Institute of Information and Computing Sciences, Utrecht University P.O.Box 80.089, 3508 TB Utrecht, The Netherlands fralf,johanj,[email protected] http://www.cs.uu.nl/~fralf,johanj,andresg/ 3 Open University, Heerlen, The Netherlands Abstract. A polytypic function is a function that can be instantiated on many data types to obtain data type specific functionality. Examples of polytypic functions are the functions that can be derived in Haskell, such as show, read, and ‘ ’. More advanced examples are functions for digital searching, pattern matching, unification, rewriting, and structure editing. For each of these problems, we not only have to define poly- typic functionality, but also a type-indexed data type: a data type that is constructed in a generic way from an argument data type. For ex- ample, in the case of digital searching we have to define a search tree type by induction on the structure of the type of search keys. This paper shows how to define type-indexed data types, discusses several examples of type-indexed data types, and shows how to specialize type-indexed data types. The approach has been implemented in Generic Haskell, a generic programming extension of the functional language Haskell. 1 Introduction A polytypic (or generic, type-indexed) function is a function that can be instan- tiated on many data types to obtain data type specific functionality.
    [Show full text]