Chicken » Deviations from the standard

## Confirmed deviations

Identifiers are by default case-sensitive (see Using the compiler).

### Number of arguments to procedures and macros

The maximal number of arguments that may be passed to a compiled procedure or macro is limited to around 1000. Likewise, the maximum number of values that can be passed to continuations captured using `call-with-current-continuation` is 1000. This is an implementation restriction that is unlikely to be lifted.

### `numerator`, `denominator` and `rationalize`

The `numerator` and `denominator` procedures cannot be applied to inexact numbers, and the procedure `rationalize` is not implemented at all.

### Numeric string-conversion considerations

The runtime system uses the numerical string-conversion routines of the underlying C library and so does only understand standard (C-library) syntax for floating-point constants. Consequently, the procedures `string->number`, `read`, `write`, and `display` do not obey read/write invariance to inexact numbers.

### Environments and non-standard syntax

In addition to the standard bindings `scheme-report-environment` and `null-environment` contain additional non-standard bindings for the following syntactic forms: `import`, `require-extension`, `require-library`, `begin-for-syntax`, `export`, `module`, `cond-expand`, `syntax`, `reexport`, `import-for-syntax`.

## Unconfirmed deviations

### `char-ready?`

The procedure `char-ready?` always returns `#t` for terminal ports.

## Doubtful deviations

### `letrec`

`letrec` does evaluate the initial values for the bound variables sequentially and not in parallel, that is:

    (letrec ((x 1) (y 2)) (cons x y))

is equivalent to

    (let ((x (void)) (y (void)))
      (set! x 1)
      (set! y 2)
      (cons x y) )

where R5RS requires

    (let ((x (void)) (y (void)))
      (let ((tmp1 1) (tmp2 2))
        (set! x tmp1)
        (set! y tmp2)
        (cons x y) ) )

It is unclear whether R5RS permits this behavior or not; in any case, this only affects letrecs where the bound values are not lambda-expressions.

## Non-deviations that might surprise you

### `let-syntax` and `letrec-syntax`

`let-syntax` and `letrec-syntax` introduce a new scope.

### `equal?` compares all structured data recursively

`equal?` compares all structured data with the exception of procedures recursively, while R5RS specifies that `eqv?` is used for data other than pairs, strings and vectors. However, R5RS does not dictate the treatment of data types that are not specified by R5RS

### No built-in support for bignums

There is no built-in support for exact rationals, complex numbers or extended-precision integers (bignums). The routines `complex?`, `real?` and `rational?` are identical to the standard procedure `number?`. The procedures `make-rectangular` and `make-polar` are not implemented. Fixnums are limited to 2^30 (or 2^62 on 64-bit hardware). Support for the full numeric tower is available as a separate package (see the `numbers` package).

### `transcript-on` and `transcript-off` are not implemented

The `transcript-on` and `transcript-off` procedures are not implemented. R5RS does not require them.

Previous: The R5RS standard

Next: Extensions to the standard