On Understanding Data Abstraction... Revisited

Transcription

1 On Understanding Data Abstraction... Revisited

2 William R. Cook The University of Texas at Austin Dedicated to P. Wegner

3 Objects???? Abstract Data Types

4 Ignore non-essentials:

5 Objects Model the Real World

6 Inheritance

7 Mutable State

8 Subtyping

9 ...these are not essential for OOP (very nice but not essential)

10 Essential: Interfaces as types

11 [ ] discuss inheritance later

12 Abstraction

13

14 Visible Hidden

15 Procedural Abstraction bool f(int x) { }

16 Procedural Abstraction int bool

17 (one kind of) Type Abstraction class Set<T>

18 (one kind of) Type Abstraction T.Set[T]

19 Abstract Data Type signature Set empty insert isempty contains : Set : Set, Int Set : Set Bool : Set, Int Bool

20 Abstract Data Type signature Set Abstract empty insert isempty contains : Set : Set, Int Set : Set Bool : Set, Int Bool

21 Type + Operations

22 ADT Implementation abstype Set = List of Int empty = [] insert(s, n) = (n : s) isempty(s) = (s == []) contains(s, n) = (n s)

23 Using ADT values Set x = empty Set y = insert(x, 3) Set z = insert(y, 5) print( contains(z, 2) ) ==> false

24

25 Visible name: Set Hidden representation: List of Int

26 ISetModule = Set.{ empty insert : Set : Set, Int Set isempty : Set Bool contains : Set, Int Bool }

27 Natural!

28 just like built-in types

29 Mathematical Abstract Algebra

30 Type Theory x.p (existential types)

31 Abstract Data Type = Data Abstraction

32 Right?

33 S = { 1, 3, 5, 7, 9 }

34 Another way

35 P(n) = even(n) & 1 n 9

36 S = { 1, 3, 5, 7, 9 } P(n) = even(n) & 1 n 9

37 Sets as characteristic functions

38 type Set = Int Bool

39 Empty = n. false

40 Insert(s, m) = n. (n==m) or s(n)

41 Using them is easy Set x = Empty Set y = Insert(x, 3) Set z = Insert(y, 5) print( z(2) ) ==> false

42 So What?

43 Flexibility

44 set of all even numbers

45 Set ADT: Not Allowed!

46 or break open ADT & change representation

47 set of even numbers as a function?

48 Even = n. (n % 2 == 0)

49 Even interoperates Set x = Even Set y = Insert(x, 3) Set z = Insert(y, 5) print( z(2) ) ==> true

50 Sets-as-functions are objects!

51 No type abstraction type Set = Int Bool

52 multiple methods? sure...

53 interface Set { contains: Int Bool isempty: Bool }

54 What about Empty and Insert? (they are classes)

55 class Empty { contains(n) { return false;} isempty() { return true;} }

56 class Insert(s, m) { contains(n) { return (n==m) or s.contains(n); } isempty() { return false; } }

57 Using Classes Set x = Empty() Set y = Insert(x, 3) Set z = Insert(y, 5) print( z.contains(2) ) ==> false

58 An object is the set of observations that can be made upon it

59 Including more methods

60 interface Set { contains: Int Bool isempty: Bool insert : Int Set }

61 interface Set { contains: Int Bool isempty: Bool insert : Int Set } Type Recursion

62 class Empty { contains(n) { return false;} isempty() { return true;} insert(n) { return Insert(this, n);} }

63 class Empty { contains(n) { return false;} isempty() { return true;} insert(n) { return Insert(this, n);} } Value Recursion

64 Using objects Set x = Empty Set y = x.insert(3) Set z = y.insert(5) print( z.contains(2) ) ==> false

65 Autognosis

66 Autognosis An object can only access other objects through public interfaces

67 operations on multiple objects?

68 union of two sets

69 class Union(a, b) { contains(n) { a.contains(n) or b.contains(n); } isempty() { a.isempty(n) and b.isempty(n); }... }

70 interface Set { contains: Int Bool isempty: Bool insert union : Int Set : Set Set } Complex Operation (binary)

71 intersection of two sets??

72 class Intersection(a, b) { contains(n) { a.contains(n) and b.contains(n); } } isempty() {???no way!??? }...

73 Autognosis: complicates some operations (complex ops)

74 Autognosis: complicates some optimizations (complex ops)

75 Inspecting two representations & optimization is easy in ADT

76 Objects are fundamentally different from ADTs

77 Object Interface (recursive types) Set = { isempty : Bool contains : Int Bool insert : Int Set union : Set Set } Empty : Set Insert : Set, Int Set Union : Set, Set Set ADT (existential types) SetImpl = Set. { empty : Set isempty : Set Bool contains : Set, Int Bool insert : Set, Int Set union : Set, Set Set }

78 Operations/Observations s Empty Insert(s', m) isempty(s) true false contains(s, n) false n=m contains(s', n) insert(s, n) Insert(s, n) Insert(s, n) union(s, s'') s'' Union(s, s'')

79 ADT Organization s Empty Insert(s', m) isempty(s) true false contains(s, n) false n=m contains(s', n) insert(s, n) Insert(s, n) Insert(s, n) union(s, s'') s'' Union(s, s'')

80 OO Organization s Empty Insert(s', m) isempty(s) true false contains(s, n) false n=m contains(s', n) insert(s, n) Insert(s, n) Insert(s, n) union(s, s'') s'' Union(s, s'')

81 Objects are fundamental (too)

82 Mathematical functional representation of data

83 Type Theory x.p (recursive types)

84 ADTs require a static type system

85 Objects work great with dynamic typing

86 Binary Operations? Stack, Socket, Window, Service, DOM, Enterprise Data,...

87 Objects are very higher-order (functions passed as data and returned as results)

88 Verification

89 ADTs: construction Objects: observation

90 ADTs: induction Objects: coinduction complicated by: callbacks, state

91 Objects are designed to be as difficult as possible to verify

92 Simulation One object can simulate another! (identity is bad)

93 Java

94 What is a type?

95 Declare variables Classify values

96 Class as type => representation

97 Class as type => ADT

98 Interfaces as type => behavior pure objects

99 Harmful! instanceof Class (Class) exp Class x;

100 Object-Oriented subset of Java: class name is only after new

101 Its not an accident that int is an ADT in Java

102 Smalltalk

103 class True iftrue: a iffalse: b ^a value class False iftrue: a iffalse: b ^b value

104 True = a. b. a False = a. b. b

105 Inheritance (in one slide) (animated)

106 Inheritance Object A

107 Inheritance Object Modification A (A) A

108 Inheritance Object Modification A Self-reference G Y(G) (A) A

109 Inheritance Object Modification A Self-reference G Y(G) A (A) G (Y(G))

110 Inheritance Object Modification A (A) A Self-reference G G Y(G) Inheritance G Y( G) (Y(G))

111 History

112 User-defined types and procedural data structures as complementary approaches to data abstraction by J. C. Reynolds New Advances in Algorithmic Languages INRIA, 1975

113 Abstract data types User-defined types and objects procedural data structures as complementary approaches to data abstraction by J. C. Reynolds New Advances in Algorithmic Languages INRIA, 1975

114 [an object with two methods] is more a tour de force than a specimen of clear programming. - J. Reynolds

115 Extensibility Problem (aka Expression Problem) 1975 Discovered by J. Reynolds 1990 Elaborated by W. Cook 1998 Renamed by P. Wadler 2005 Solved by M. Odersky (?) 2025 Widely understood (?)

116 Summary

117 It is possible to do Object-Oriented programming in Java

118 Lambda-calculus was the first object-oriented language (1941)

119 Data Abstraction / \ ADT Objects