1 / 71

Data Types in Programming Languages

Explore the significance of data types in programming, including data abstraction, type checking, and compile-time code generation. Learn about different type systems, sound type systems, strongly typed languages, static vs. dynamic types, type checking methods, type declarations, type inference, and type judgments.

graham-acosta
Télécharger la présentation

Data Types in Programming Languages

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programming Languages and Compilers (CS 421) Dennis Griffith 0207 SC, UIUC http://www.cs.illinois.edu/class/cs421/ Based in part on slides by Mattox Beckman, as updated by Vikram Adve, Gul Agha, and Elsa Gunter

  2. Why Data Types? • Data types play a key role in: • Data abstraction in the design of programs • Type checking in the analysis of programs • Compile-time code generation in the translation and execution of programs

  3. Terminology • Type: A type t defines a set of possible data values • E.g. short in C is {x| 215 - 1  x  -215} • A value in this set is said to have type t • Type system: rules of a language assigning types to expressions

  4. Types as Specifications • Types describe properties • Different type systems describe different properties, eg • Data is read-write versus read-only • Operation has authority to access data • Data came from “right” source • Operation might or could not raise an exception • Common type systems focus on types describing same data layout and access methods

  5. Sound Type System • If an expression is assigned type t, and it evaluates to a value v, then v is in the set of values defined by t • SML, OCAML, Scheme and Ada have sound type systems • Most implementations of C and C++ do not

  6. Strongly Typed Language • When no application of an operator to arguments can lead to a run-time type error, language is strongly typed • Eg: 1 + 2.3;; • Depends on definition of “type error”

  7. Strongly Typed Language • C++ claimed to be “strongly typed”, but • Union types allow creating a value at one type and using it at another • Type coercions may cause unexpected (undesirable) effects • No array bounds check (in fact, no runtime checks at all) • SML, OCAML “strongly typed” but still must do dynamic array bounds checks, runtime type case analysis, and other checks

  8. Static vs Dynamic Types • Static type: type assigned to an expression at compile time • Dynamic type: type assigned to a storage location at run time • Statically typed language: static type assigned to every expression at compile time • Dynamically typed language: type of an expression determined at run time

  9. Type Checking • When is op(arg1,…,argn) allowed? • Type checkingassures that operations are applied to the right number of arguments of the right types • Right type may mean same type as was specified, or may mean that there is a predefined implicit coercion that will be applied • Used to resolve overloaded operations

  10. Type Checking • Type checking may be done staticallyat compile timeor dynamically at run time • Dynamically typed languages (e.g., LISP, Python) do only dynamic type checking • Statically typed languages can do most type checking statically

  11. Dynamic Type Checking • Performed at run-time before each operation is applied • Types of variables and operations left unspecified until run-time • Same variable may be used at different types

  12. Dynamic Type Checking • Data object must contain type information • Errors aren’t detected until violating application is executed (maybe years after the code was written)

  13. Static Type Checking • Performed after parsing, before code generation • Type of every variable and signature of every operator must be known at compile time

  14. Static Type Checking • Can eliminate need to store type information in data object if no dynamic type checking is needed • Catches many programming errors at earliest point • Can’t check types that depend on dynamically computed values • Eg: array bounds

  15. Static Type Checking • Typically places restrictions on languages • Garbage collection • References instead of pointers • All variables initialized when created • Variable only used at one type • Union types allow for work-arounds, but effectively introduce dynamic type checks

  16. Type Declarations • Type declarations: explicit assignment of types to variables (signatures to functions) in the code of a program • Must be checked in a strongly typed language • Often not necessary for strong typing or even static typing (depends on the type system)

  17. Type Inference • Type inference: A program analysis to assign a type to an expression from the program context of the expression • Fully static type inference first introduced by Robin Miller in ML • Haskell, OCAML, SML use type inference • Records are a problem for type inference

  18. Format of Type Judgments • A type judgement has the form  |- exp :  •  is a typing environment • Supplies the types of variables and functions •  is a list of the form [ x : , . . . ] • exp is a program expression •  is a type to be assigned to exp • |- pronounced “turnstyle”, or “entails” (or “satisfies”)

  19. Example Valid Type Judgments • [ ] |- true or false : bool • [ x : int] |- x + 3 : int • [ p : int -> string ] |- p(5) : string

  20. Format of Typing Rules Assumptions 1 |- exp1 : 1 . . . n |- expn : n  |- exp :  Conclusion • Idea: Type of expression determined by type of components • Rule without assumptions is called an axiom •  may be omitted when empty

  21. Format of Typing Rules Assumptions 1 |- exp1 : 1 . . . n |- expn : n  |- exp :  Conclusion • , exp,  are parameterized environments, expressions and types - i.e. may contain meta-variables

  22. Axioms - Constants |- n : int (assuming n is an integer constant) |- true : bool |- false : bool • These rules are true with any typing environment • n is a meta-variable

  23. Axioms - Variables Notation: Let (x) =  if x :    and there is no x :  to the left of x :  in  Variable axiom:  |- x :  if (x) = 

  24. Simple Rules - Arithmetic Primitive operators (   { +, -, *, …}):  |- e1 : int  |- e2 : int  |- e1  e2 : int Relations ( ˜  { < , > , =, <=, >= }):  |- e1 : int  |- e2 : int  |- e1˜ e2 :bool

  25. Simple Rules - Booleans Connectives  |- e1 : bool  |- e2 : bool  |- e1 && e2 : bool  |- e1 : bool  |- e2 : bool  |- e1 || e2 : bool

  26. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Start building the proof tree from the bottom up ?  |- y || (x + 3 > 6) : bool

  27. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- y || (x + 3 > 6) : bool

  28. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Booleans: ||  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  29. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  30. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  31. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Axiom for variables  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  32. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  33. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  34. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Arithmetic relations  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  35. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  36. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  37. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Axiom for constants  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  38. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  39. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  40. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Arithmetic operations  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  41. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  42. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  43. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Axiom for constants  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  44. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Pick an assumption to prove ?  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  45. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Which rule has this as a conclusion? ?  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  46. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • Axiom for variables  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  47. Simple Example • Let  = [ x:int ; y:bool] • Show  |- y || (x + 3 > 6) : bool • No more assumptions! DONE!  |- x : int  |- 3 : int  |- x + 3 : int  |- 6 : int  |- y : bool  |- x + 3 > 6 : bool  |- y || (x + 3 > 6) : bool

  48. Type Variables in Rules • If_then_else rule:  |- e1 : bool  |- e2 :   |- e3 :   |- (if e1 then e2 elsee3):  •  is a type variable (meta-variable) • Can take any type at all • All instances in a rule application must get same type • Then branch, else branch and if_then_else must all have same type

  49. Function Application • Application rule:  |- e1 : 1  2 |- e2 : 1  |- (e1e2): 2 • If you have a function expression e1 of type 1  2 applied to an argument of type 1, the resulting expression has type 2

  50. Application Examples  |- print_int : int  unit  |- 5 : int  |- (print_int 5) : unit • e1 = print_int, e2 = 5, • 1 = int, 2 = unit  |- map print_int : int list  unit list  |- [3;7] : int list  |- (map print_int [3; 7]) : unit list • e1 = map print_int, e2 = [3; 7], • 1 = int list, 2 = unit list

More Related