No.3 Lecture - PLD Structuring the Data
Definition of DT, ADT Built-in / primitive types Structured / composite types - aggregates Homogeneous / heterogeneous types Type constructor Accessing the elements / components of an aggregate
Categories of aggregates
1. 2. 3. 4. Finite mappings / arrays Structures / Cartesian product Sequence, Recursive structures Unions and discriminated unions
UNIONS C typedef union {short int offset; long unsigned int absolute; } address; typedef enum {abs, rel} descriptor ; typedef struct {address location; descriptor kind;} safe_address; DISCRIMINATED UNIONS Scheme (define-datatype bintree bintree? (leaf (datum number?)) (node (key symbol?) (left bintree?) (right bintree?))) (define tree_a (node a (leaf 2) (leaf 3)) (define tree_b (node b (leaf 5) tree_a))
C
VERSION 1 typedef struct {char key; union tree * left, * right;} intnode; typedef union {int leaf_node; intnode int_node; } tree; VERSION 2 not identical but probably more natural typedef union {int leaf; char intnode;} node_type; typedef struct {node_type key; struct tree1 *left, *right;} tree1; Abstract Data Types C class Stack { public: Stack(int sz) ~Stack() void push(int el) int pop() int length() private: int size; int *top; int *s; }; void foo() { Stack int_stack(30); int_stack.push(9); }
{top=s=new int [size=sz];} {delete[] s;} {*top++=el;} {return *--top;} {return top - s;}
2
Generic ADTs
template <class T> class Stack { public: Stack(int sz) {top=s=new T [size=sz];} ~Stack() {delete[] s;} void push(T el) {*top++=el;} T pop() {return *--top;} int length() {return top - s;} private: int size; T *top; T *s; }; void foo() { Stack<int> int_stack(30); int_stack.push(9); } ADT in Lisp is generic? (defun resetstack (stack) (setf stack nil)) (defun emptystack (stack) (null stack)) (defun push (x list) (setf list (cons x list))) (defun pop (stack) (if (null stack) (error Empty (let stack) ((result (first list))) (setf list (rest list)) result)))
3
ADT queue in Scheme (define create-queue (lambda () (let ((q-in '()) (q-out '())) (letrec ((reset-queue (lambda () (set! q-in '()) (set! q-out '()))) (empty-queue? (lambda () (and (null? q-in) (null? q-out)))) (enqueue (lambda (x) (set! q-in (cons x q-in)))) (dequeue (lambda () (if (empty-queue?) (eopl:error 'dequeue "Not on an empty queue") (begin (if (null? q-out) (begin (set! q-out (reverse q-in)) (set! q-in '()))) (let ((ans (car q-out))) (set! q-out (cdr q-out)) ans)))))) (vector reset-queue empty-queue? enqueue dequeue))))) (define queue-get-reset-operation (lambda (q) (vector-ref q 0))) (define queue-get-empty?-operation (lambda (q) (vector-ref q 1))) (define queue-get-enqueue-operation (lambda (q) (vector-ref q 2))) (define queue-get-dequeue-operation (lambda (q) (vector-ref q 3)))
4
Type Systems What is a type system? What is a type safe program (or type secure program)? Static versus dynamic program checking Strong typing versus weak typing languages Type compatibility
type s1 is struct { int y; int w;}; type s2 is struct { int y; ...