source: project/wiki/language-comparison @ 8585

== Input & output

<table>

<tr>
<td></td>
<td>Chicken</td>
<td>C</td>
<td>Python</td>
</tr>

<tr>
<td>Formatting and printing to stdout</td>
<td><enscript highlight="scheme">(format #t "I want ~A ~A~%" count desc)</enscript></td>
<td>printf("I want %d %s\n", count, desc);</td>
<td>...</td>
</tr>

<tr>
<td>Printing to stderr</td>
<td><enscript highlight="scheme">(format (current-error-port) "Ooops~%")</enscript></td>
<td>fprintf(stderr, "Ooops\n");</td>
<td>...</td>
</tr>

<tr>
<td>Reading a line from stdin</td>
<td><enscript highlight="scheme">(read-line)</enscript></td>
<td><enscript highlight="c">char buffer[1024];
fgets(buffer, sizeof(buffer)/sizeof(buffer[0], stdin);</enscript></td>
<td>...</td>
</tr>


<tr>
<td>Opening a file for input</td>
<td><enscript highlight="scheme">(open-input-file path)</enscript></td>
<td><enscript highlight="c">fopen(path, "r");</enscript></td>
<td>...</td>
</tr>


<tr>
<td>Opening a file for output</td>
<td><enscript highlight="scheme">(open-output-file path)</enscript></td>
<td><enscript highlight="c">fopen(path, "w");</enscript></td>
<td>...</td>
</tr>


<tr>
<td>Count lines in a file</td>
<td><enscript highlight="scheme">(with-input-from-file path
  (lambda ()
    (let loop ((count 0))
      (if (eof-object? (read-line))
        count
        (loop (+ count 1)))))))</enscript>

If you don't want to keep an entire line in memory at any time:

<enscript highlight="scheme">(with-input-from-file path
  (lambda ()
    (let loop ((count 0) (c (read-char)))
      (if (eof-object? c)
        count
        (loop (if (char=? c #\newline) (+ count 1) count) (read-char))))))</enscript>
</td>
<td><enscript highlight="c">FILE *in = fopen(path, "r");
int c, count = 0;
if (!in)
  handle_error();
while ((c = fgetc(in)) != EOF)
  if (c == '\n')
    lines ++;
fclose(in);
return count;</enscript></td>
<td>...</td>
</tr>

<tr>
<td>Write a file with some numbers

In practice you'd probably collapse the calls to format and equivalent functions in a single call.
</td>
<td><enscript highlight="scheme">(with-output-to-file path
  (lambda ()
    (format #t "~A~%" 1)
    (format #t "~A~%" 2)
    (format #t "~A~%" 3)))</enscript></td>
<td><enscript highlight="c">FILE *out = fopen(path, "w");
if (!out)
  handle_error();
fprintf(out, "%d\n", 1);
fprintf(out, "%d\n", 2);
fprintf(out, "%d\n", 3);
if (!fclose(out))
  handle_error();</enscript></td></tr>
</table>

== Lists

== Vectors

<table>
<tr>
<td>Declaring a vector of numbers</td>
<td>An anonymous vector is declared as:

<enscript highlight="scheme">`#(1 2 ,x ,y 5)</enscript>

To declare it as a global variable:

<enscript highlight="scheme">(define *my-vector* `#(1 2 ,x ,y 5))</enscript>

Or, to declare it locally for some body of code:

<enscript highlight="scheme">(let ((vector `#(1 2 ,x ,y 5)))
  body-of-code ...)</enscript></td>
<td>
<enscript highlight="c">int vector[] = { 1, 2, x, y, 5 };</enscript>
</td>
</tr>

<tr>
<td>Obtaining the size of a vector</td>
<td><enscript highlight="scheme">(vector-length my-vector)</enscript></td>
<td>If the size of the vector is known at compile time:

<enscript highlight="c">sizeof(my_vector)/sizeof(my_vector[0])</enscript>

This often does not happen.  If the vector is terminated with a special element
(such as a NULL pointer or —as in the case of strings— a 0), you'll have to traverse it:

<enscript highlight="c">int i;
for (i = 0; my_vector[i] != SPECIAL_ELEMENT; i ++);</enscript></td>
</tr>

<tr>
<td>Printing a vector</td>
<td>If you don't care that much about the format used:

<enscript highlight="scheme">(format "~A~%" vector)</enscript>

If you need a newline after each element and can afford the vector to be converted to a list:

<enscript highlight="scheme">(use format-modular)
(format "~{~A~%~}" (vector->list vector))</enscript>

Without converting the vector to list:

<enscript highlight="scheme">(do ((i 0 (+ i 1)))
    ((= i (vector-length vector)))
  (format #t "~A~%" (vector-ref vector i)))</enscript>
</td>
<td>
<enscript highlight="c">int i;
for (i = 0; i < n; i ++)
  printf("%d\n", vector[i]);</enscript>
</td>
<td>...</td>
</tr>

</table>

== Hash tables

<table>
<tr>
<td></td>
<td>Chicken</td>
<td>C++ (STL)</td>
<td>Python</td>
<td>Perl</td>
</tr>

<tr>
<td>Creating a hash table</td>
<td><enscript highlight="scheme">(make-hash-table)</enscript>

If you need to populate the hash table, you'll probably use {{alist->hash-table}}:
<enscript highlight=scheme>(alist->hash-table '((1 . "uno") (2 . "dos")))</enscript>

Note that the list can be created at runtime.</td>
<td><enscript highlight="cpp">map<int, string> my_hash;
my_hash[1] = "uno";
my_hash[2] = "dos";</enscript></td>
<td></td>
<td>
<enscript highlight="perl">my %hash = (
  1 => 'uno',
  2 => 'dos'
);</enscript></td>
</tr>

<tr>
<td>Obtaining an element from a hash</td>
<td><enscript highlight=scheme>(hash-table-ref/default my_hash 2 #f)</enscript>

This will return #f (false) if the element is not defined.  If you prefer to have an error thrown, you should use:

<enscript highlight=scheme>(hash-table-ref my_hash 2)</enscript></td>
<td>my_hash[2]</td>
<td></td>
<td><enscript highlight="perl">$my_hash{2}</enscript></td>
</tr>

<tr>
<td>Printing the keys in the hash</td>
<td>If you can afford to have a list with the keys created, you should do this:
<enscript highlight=scheme>(format #t "~{~A~}~%" (hash-table-keys my_hash))</enscript>

Otherwise, do this:

<enscript highlight=scheme>(hash-table-walk
  my-hash
  (lambda (key value)
    (format #f "~A~%" key)))</enscript></td>
<td><enscript highlight="cpp">for(map<int, string>::iterator iter = my_hash.begin();
    it != my_hash.end(); it++ )
  cout << it->first << endl;</enscript>
</td>
<td></td>
<td><enscript highlight=perl>for my $key ( keys %my_hash ) {
  print "$key\n";
}</enscript></td></tr>
</table>