## 1.11  Non reactive higher-order features

Besides this functional facility, we can also define recursive functions, such as the celebrated Eratosthenes sieve:

```let node first x = v
where rec v = x fby v

let rec node sieve x =
let clock filter = (x mod (first x))<> 0
in  merge filter
(sieve (x when filter))
(true fby false)

let node from n = o where rec o = n fby (o + 1)

let clock sieve = sieve (from 2)

let node primes () = (from 2) when sieve

val first :  ’a => ’a
val first :: ’a -> ’a
val sieve :  int => bool
val sieve :: ’a -> ’a
val from :  int => int
val from :: ’a -> ’a
val sieve :  bool
val sieve :: ’a
val primes :  unit => int
val primes :: ’a -> ’b on sieve
```

This program is no more real-time since the time and memory to answer at every instant grows.

A compilation option `-realtime` is provided for restricting the language to define only real-time programs.

Here is another way of writing the same program using the implicit filtering of streams done by the pattern matching construct:

```let rec node sieve x =
let filter = (x mod (first x))<> 0 in
match filter with
true -> sieve x
| false -> true fby false
end

let node primes () =
let nat = from 2 in
let clock ok = sieve n in
let emit o = n when ok in
o

val sieve :  int => bool
val sieve :: ’a -> ’a
val primes :  unit => int sig
val primes :: ’a -> ’b sig
```

Note that in these two versions, the absence of unbounded instantaneous recursion is somehow hidden: the program is reactive because the very first value of `filter` is false. Here is a guarded version where no instantaneous recursion can occur.

```let rec node sieve x =
automaton
Await -> true then Once(x)
| Once(i) ->
match not_divides_l i x with
true -> sieve x
| false -> false
end
end
```