title: Can I use a list as a hash in R? If so, why is it so slow?
body: <p>Before using R, I used quite a bit of Perl. In Perl, I would often use hashes, and lookups of hashes are generally regarded as fast in Perl.</p>
  
  <p>For example, the following code will populate a hash with up to 10000 key/value pairs, where the keys are random letters and the values are random integers. Then, it does 10000 random lookups in that hash.</p>
  
  <pre><code>#!/usr/bin/perl -w
  use strict;
  
  my @letters = ('a'..'z');
  
  print @letters . "\n";
  my %testHash;
  
  for(my $i = 0; $i &lt; 10000; $i++) {
      my $r1 = int(rand(26));
      my $r2 = int(rand(26));
      my $r3 = int(rand(26));
      my $key = $letters[$r1] . $letters[$r2] . $letters[$r3];
      my $value = int(rand(1000));
      $testHash{$key} = $value;
  }
  
  my @keyArray = keys(%testHash);
  my $keyLen = scalar @keyArray;
  
  for(my $j = 0; $j &lt; 10000; $j++) {
      my $key = $keyArray[int(rand($keyLen))];
      my $lookupValue = $testHash{$key};
      print "key " .  $key . " Lookup $lookupValue \n";
  }
  </code></pre>
  
  <p>Now that increasingly, I am wanting to have a hash-like data structure in R. The following is the equivalent R code:</p>
  
  <pre><code>testHash &lt;- list()
  
  for(i in 1:10000) {
    key.tmp = paste(letters[floor(26*runif(3))], sep="")
    key &lt;- capture.output(cat(key.tmp, sep=""))
    value &lt;- floor(1000*runif(1))
    testHash[[key]] &lt;- value
  }
  
  keyArray &lt;- attributes(testHash)$names
  keyLen = length(keyArray);
  
  for(j in 1:10000) {
    key &lt;- keyArray[floor(keyLen*runif(1))]
    lookupValue = testHash[[key]]
    print(paste("key", key, "Lookup", lookupValue))
  }
  </code></pre>
  
  <p>The code seem to be doing equivalent things. However, the Perl one is much faster:</p>
  
  <pre><code>&gt;time ./perlHashTest.pl
  real    0m4.346s
  user    **0m0.110s**
  sys 0m0.100s
  </code></pre>
  
  <p>Comparing to R:</p>
  
  <pre><code>time R CMD BATCH RHashTest.R
  
  real    0m8.210s
  user    **0m7.630s**
  sys 0m0.200s
  </code></pre>
  
  <p>What explains the discrepancy? Are lookups in R lists just not good?</p>
  
  <p>Increasing to 100,000 list length and 100,000 lookups only exaggerates the discrepancy? Is there a better alternative for the hash data structure in R than the native list()?</p>