Cloud diagrams

• Perl data structures can be difficult to unravel.
• One major aid: cloud diagrams.
• Game: represent enough of Perl structure to help you think, but not too much.
• Major advantage: syntactic rules take visual form.

Basic cloud diagrams

• Represent a hash by a cloud of associations.
• Represent an array by a box of boxes.
• A reference to array points to the outer box.
• Each cell can contain either a regular value (string or number) or another reference (pointer).
  
  In this image,
  • The cloud is the hash %foo, the reference \%foo points to the cloud.
  • The box is the array @bar, the reference \@bar points to it.
• Likewise, for references,
  
  
  • The reference {...} points to a cloud.
  • The reference [...] points to a box.

Visual model of assignment

• $a->{'hi'}='ho' means:
  • Make a cloud that $a points to.
  • Instantiate an element (index) in that cloud whose name is 'hi'.
  • point from that index to the value 'ho'.
    
    
  • Multiple clouds result from chains of references. E.g., $a->{'cat'}->{'dog'}='horse' would change this to:
    
    
  • For arrays, substitute boxes for clouds. For example,
  • $a->{'hoe'}->[2]='hello'
    
    

Graphical models of complex constructions

• Composition of inline and assignment-based constructions. Consider:

   $foo->{'bar'}={'a'=>[0,1,2]}

  
  
  
• Deleting a reference is deleting the key from the cloud. After delete $foo->{'bar'}, we have:
  
  

Graphical principles of Perl data structures

• Clouds come into being when needed.
• Adding an element to a hash makes its key appear in its cloud.
• Deleting an element erases its key from the cloud (and does nothing else).
• Deleting a hash element requires access to the hash cloud. You need to reference the cloud in your expression.

   $h = $foo->{'bar'}; delete $h

  doesn't work (or even make sense, because the value $h might be in two or more hashes)!
• Cloud elements remain aliased to any other variables that might be in scope.
• An assignment statement for a pointer value (reference) points where the original pointer pointed.
• Clouds do not change into boxes (or vice versa) when needed. Using a cloud as a box is a runtime error.

A complex example

• Let's fully model edge creation and deletion in a graph. Consider:

   
  my $tuples = [['a','b',10],['a','c',20],['d','b',5]]; 
  foreach my $t (@$tuples) { 
      $edges->{$t->[0]}->{$t->[1]}=$t->[2];
  } 
  delete $edges->{'a'}->{'b'}; 
  delete $edges->{'a'} if %{$edges->{'a'}} == 0; 
  

• After the first loop:
  
  
• After the second loop:
  
  
• After the third loop:
  
  
• After deletion:
  
  

Tuples, indices, and aliases

• Consider the following code:

   
  my $tuples = [['a','b',10],['a','c',20],['d','b',5]]; 
  foreach my $t (@$tuples) { 
      $edges->{$t->[0]}->{$t->[1]}=$t; 
  } 
  

  The previous code just made an equivalent hash. This code instead points the hash at the elements, creating aliases:
  
  
• Now $foo->{'a'}->{'b'} and $tuples->[0] refer to exactly the same location.
• We can use this construction to make multiple indexes to the same data. Consider:

  my $tuples = [['a','b',10],['a','c',20],['d','b',5]];
  foreach my $t (@$tuples) {
      $forward->{$t->[0]}->{$t->[1]}=$t;
      $backward->{$t->[1]}->{$t->[0]}=$t;
  }
  

  This produces: