Hamming Numbers

The Hamming numbers are all integers of the form 2ⁱ×3^j×5^k, for i, j, k ≥ 0, i.e., 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 16, ...

Note the use of unbounded buffers in the following program. If a buffer is empty it will only input and store a value. If it is non-empty it will either input and store a value or output the oldest value in its keeping.

let rec
  limit = 200,  {Hammings are really unlimited}

add = lambda x. lambda list. {add element x to end of list}
     if null list then x::nil else hd list :: add x  tl list,

buffer = lambda inc. lambda opc. {buffer inc onto opc}
    let rec
       b = lambda buff. {NB. unbounded buffer}
          if null buff then
               ?inc        -> lambda x. b (x::nil)
          else opc!hd buff -> b tl buff     |
               ?inc        -> lambda x. b (add x buff)
    in b nil,

unique = lambda inc. lambda op. {op is inc less any duplicates}
    let rec u = lambda last. ?inc -> lambda x.
             if x=last then u last else op!x -> u x
    in ?inc -> lambda x. op!x -> u x,

merge = lambda in1. lambda in2. lambda op. {infinite steams}
    let rec
      m = lambda x1. lambda x2.
        if x1 > limit and x2 > limit then stop else
        if x1<=x2 then op!x1 -> ?in1 -> lambda y. m y x2
                  else op!x2 -> ?in2 -> lambda z. m x1 z
    in ?in1 -> lambda x1. ?in2 -> lambda x2. m x1 x2  |
       ?in2 -> lambda x2. ?in1 -> lambda x1. m x1 x2,

merge3 = lambda in1. lambda in2. lambda in3. lambda op.
    let temp = chan
    in merge in2 in3 temp || merge in1 temp op,

fan4 = lambda inc. lambda op1. lambda op2. lambda op3. lambda op4.
    let rec fan = {4-way fan out}
       ?inc -> lambda x. op1!x -> op2!x -> op3!x -> op4!x -> fan
    in fan,

times = lambda n. lambda inc. lambda opc.
    ?inc     -> lambda x. let nx = n*x in
    opc ! nx -> times n inc opc,

in2 =chan, in3 =chan, in5 =chan, {declare channels}
  out2=chan, out3=chan, out5=chan, {to join}
  b2  =chan, b3  =chan, b5  =chan, {system}
  mergeout=chan, uniq = chan       {together}

in times 2 in2 out2               || {some Parallel Processes}
   times 3 in3 out3               ||
   times 5 in5 out5               ||
   merge3 out2 out3 out5 mergeout ||
   unique mergeout uniq           ||
   fan4 uniq stdOp b2 b3 b5       ||
   buffer b2 in2                  || {different rates}
   buffer b3 in3                  ||
   buffer b5 in5                  ||
   mergeout ! 1 -> stop  {seed the system}

The Hamming numbers go on forever but that is not going to happen here so a 'limit' is set to halt the program, which does leave a few hanging Processes remaining.