Using Understanding And Unrave The Ocaml Language

Using, Understanding, and Unraveling the OCaml Language From Practice to Theory and Vice Versa Didier R´emy INRIA-Rocquencourt http://cristal.inria.fr/∼remy

Abstract. These course notes are addressed to a wide audience of people interested in modern programming languages in general, ML-like languages in particular, or simply in OCaml, whether they are programmers or language designers, beginners or knowledgeable readers —little prerequiresite is actually assumed. They provide a formal description of the operational semantics (evaluation) and statics semantics (type checking) of core ML and of several extensions starting from small variations on the core language to end up with the OCaml language —one of the most popular incarnation of ML— including its object-oriented layer. The tight connection between theory and practice is a constant goal: formal definitions are often accompanied by OCaml programs: an interpreter for the operational semantics and an algorithm for type reconstruction are included. Conversely, some practical programming situations taken from modular or object-oriented programming patterns are considered, compared with one another, and explained in terms of typechecking problems. Many exercises with different level of difficulties are proposed all along the way, so that the reader can continuously checks his understanding and trains his skills manipulating the new concepts; soon, he will feel invited to select more advanced exercises and pursue the exploration deeper so as to reach a stage where he can be left on his own.

G. Barthe et al. (Eds.): Applied Semantics, LNCS 2395, pp. 413–536, 2002. c Springer-Verlag Berlin Heidelberg 2002


414

Didier R´emy

Table of Contents

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 2

Core ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421

2.1 2.2 2.3

Discovering Core ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Syntax of Core ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Dynamic Semantics of Core ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Reduction Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.2 Properties of the Reduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.3 Big-Step Operational Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Static Semantics of Core ML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Types and Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.2 Type Inference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.3 Unification for Simple Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.4 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1 Fix-Point Combinator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.2 Recursive Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.3 Type Inference v.s. Type Checking . . . . . . . . . . . . . . . . . . . . . . . . .

2.4

2.5

421 423 424 425 431 434 437 437 439 442 446 449 449 451 452

3

The Core of OCaml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454

3.1

3.3

Data Types and Pattern Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 Examples in OCaml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.2 Formalization of Superficial Pattern Matching . . . . . . . . . . . . . . . . 3.1.3 Recursive Datatype Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.4 Type Abbreviations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.5 Record Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mutable Storage and Side Effects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Formalization of the Store . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.2 Type Soundness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.3 Store and Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.4 Multiple-Field Mutable Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4

The Object Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465

4.1

Discovering Objects and Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Basic Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.2 Polymorphism, Subtyping, and Parametric Classes . . . . . . . . . . . . Understanding Objects and Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.1 Type-Checking Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.2 Typing Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced Uses of Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3.2

4.2

4.3

454 454 455 456 457 458 459 459 461 462 462 462

465 465 468 472 474 478 482

Using, Understanding, and Unraveling the OCaml Language

415

5

The Module Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

5.1

5.2 5.3

Using Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.1 Basic Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.2 Parameterized Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced Uses of Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6

Mixing Modules and Objects . . . . . . . . . . . . . . . . . . . . . . . . . . 495

6.1 6.2

Overlapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Combining Modules and Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.1 Classes as Module Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.2 Classes as Pre-modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

487 487 491 491 491

495 496 497 498

Further Reading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 A

First Steps in OCaml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

B

Variant Types and Labeled Arguments . . . . . . . . . . . . . . . 510

B.1 B.2 B.3

Variant Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 Labeled Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512 Optional Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513

C

Answers to Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515

References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530 List of All Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534

416

Didier R´emy


 




 

 

  

    

  
   

 !  

" #$

% 

&   #$


      
  


    '   !
()      ! 


  

* +   ,$  * $   $$ $

Using, Understanding, and Unraveling the OCaml Language

417


 


                                                      Æ                      
                                          
                                           !       "                        #           $            %       &  &              #           "      '                                "     (     

          
                            
             (               &                &
            
              
 !          "                              )         *         !    "  +  Æ                   !"   &                                      
    !" !   
        
        $       &           
      ,       (                 "    "  #         #            &  

418

Didier R´emy


                      
                             
                      

                            ! "                   #                      $           %            &                                     #                ' (  (          )       $      *% +            ,   
#    $   -  .% /     $&   0%     $&   1%2     $&   3%          /     

                  ,                      4                 /    

                          (               

           ,           )                                     4             5 16.                                                ,     $      *% 5               

    -  .             / 4     
            &   0 7                        ( "     (   (                  /     2                     
      4           /                 
           (    4

    8                

          $                    % 9            :     ,            

Using, Understanding, and Unraveling the OCaml Language

419


     
 
 

  
    
     

  



 

  


     

 

   
 
  
 
 
  
        

 

   
     


    


  
 

  
 
  
  

     

 

 
    


  

   
  

  

 
 


    
   

   
 
   !
 

  

  


 
      
    


 
 
 "

 # $%&'   
     
 !
 (  
   

      
)    
  
    
  
      
        

  
 
    

 
 
   
 ) * 

      
   +  

    
   *  ,
   




   

   )    !  -. 


  

 
  
  

  
 
          

  

  "
     

   /  ,    

 *   01)  2 * 3  4
  
  




 


   
   0!
  4 1 *  #  01 
 4 5
 678

           , 
    
  

!
 

        
      
    
  
   !
 

     # 
  

 # 
    9&:6  ; #   

0 


4 
  

 
  

  
   
  


  !1 


 
  

 ) *

  
+ 
  

  ,     
  #  
  !

 ?;2 "

 #  ?@ 
   ) *)
   &12  $) )       (  )   56 @ ?
   , %% & 0 > ,  & ) $  
   $ 
&    *   ( 4  )   ,     1 
   , $  %  $ >? * 3(    "4,        1 
   , $  --- 3  5/  /-            +)=     A  1 ;# ,  #  #  9  ( (        ! "#(  8

#   $        ( % 5.-65 %?( '--5 58 ,! 1  ) 1 , Æ $ 
          ( 534"
6 ( '-  5  ! 1  1 ;#        ; 19;  ( '--' 5- ! 1( 1 ;#( ! @%(   1>  %       &'( ; 19;  ( '--8
.   1          19;  ( '--&
' 1 * 2    /0#   %   A2 9

    )* 
          ( %
56&8(  '--&
 1 * 2 ( 1 B(  1 C ; % # A    %  
!(
3'4( '---
 1 * 2 ( % C(  1 C ,  2   9

 +
  +          
   ( % '
6'5&(  '--

5 1 * 2 (  % D(  1 D    %  # 9
         ( ..'

 ,   * , % %     %
           ( '83&4" 556 -
( '--&
& /A        , -   ! )   ( '--'
8 =E   = $  ! .         ( ''3'4"''6'&
(  '--5 ,    , F    1(  (    
   !/0 !   1 2    2   3 319;  ( '--54  
         2
/2 $, 4 
 =E     : ; /  % # 9     )5 
          ( '--  +   !  9 )  9 ; % 5-

Using, Understanding, and Unraveling the OCaml Language

533

                    !

"#" $%&'
   ( )   '*' +, $ - 

   )( . (   /   (   
         0,,, +'  !1( 23  #4 ( (  5     6   ( !  ! '7++ "   %   !   ")  6     !6  8 ', 7* ' 4 ( 3 $  '0 +0  !1(    .9  5  #4&! /  3   #4 5  .     ( " # :(  ;  # 

   
                  . 7*  4   %       0'

 .9   #4/  @   .9 &   3   #4         =A'B/07 !      
   ( ) 2.  '* +*   #$%        &C ( ' + ;1 ? >

 . .   . (  /  .9    5  5 "  &      

    ! #   0,,, 7, ;1 ? >

    '   ( )     &! *    D     
   1   7  . 0,,, 7' # 

C    ( )  )   .9  "            ! 
       0,7