f# linked list implementing with records

Question

I'm trying to implement a linked list in f# using records. I know I can use the build in list type but this is for learning purposes. My type is:

type Cell = { data : int; next : RList}
and RList = Cell option ref

And I'd like to make a simple insert function, but I'm told that f# is expecting a boolean but was given an expression of type unit. I'm wondering if this means I've formatted my if/else statement incorrectly

let rec insert comp (item: int) (list: RList) =
    let c = {data = item; next = ref None}
    match !list with
     | None -> list = cellToRList c
     | Some {data = d; next = remaining} -> 
        if (comp(item, d)) then
            c.next := !remaining
            remaining := ref c (* compiler indicates error here *)
        else insert comp item remaining

Note: comp is any comparison function taking (item, d) as input and outputting true or false ex:

let compare (x, y) = x > y

My goal is simply to insert a new cell with data = item if compare outputs true. In the example above it could be used to insert into a sorted list and maintain sorted-ness. The entire function should return type unit. Any hint as to why my interpreter is looking for a boolean would be appreciated!

Note: I'm very new to F#

====

Fixed with improvements Courtesy of Foggy, Mikhail, and Fyodor

type Cell = { data : int; next : (Cell option) ref}

let rec insert compare (item: int) (list: (Cell option) ref) : unit =
    let c = {data = item; next = ref None}
    match !list with
    | None -> list := Some c
    | Some {data = d; next = remaining} -> 
        if (compare(d, item)) then
            c.next := !remaining
            remaining := Some c
        else insert compare item remaining

That doesn't answer your question, but you don't need RList : `type Cell = { data : int; next : Cell option}` https://dotnetfiddle.net/VzZwnb — FoggyFinder, Mar 06 '16 at 20:18
It's more of a convenience wrapper, unless you think it's less convenient? — Sunny, Mar 06 '16 at 20:22
Only yesterday there was a very similar question: http://stackoverflow.com/q/35816215/180286 — Fyodor Soikin, Mar 06 '16 at 20:38
Also, note that mutable data structures are bleh. The only advantage they have over immutable ones is that they _may, in principle_, be made more performant. But this does not apply to singly linked list. — Fyodor Soikin, Mar 06 '16 at 20:40
I think the use of 'mutable' in the beginning of learning F# will only harm. — FoggyFinder, Mar 06 '16 at 20:41
Incidentally I found a similar question: http://stackoverflow.com/questions/24889171/f-custom-linked-list-and-references — FoggyFinder, Mar 06 '16 at 20:50
Thanks! Although I did it slightly differently I have no problem implementing an append function. I think I'm doing something wrong with my pattern matching... I just have no idea what... — Sunny, Mar 06 '16 at 20:56
I'm trying to make sense of it Fyodor, but I'm afraid I barely understand it... I thought the <- and := operators were the same... Edit: OH looking at the wrong line of code... — Sunny, Mar 06 '16 at 21:01
Of course it's a type error, when is it ever not with F#. Thank you all for the help!!! — Sunny, Mar 06 '16 at 21:07
Can you try to write code without the 'ref Cell'? It will be much more useful. — FoggyFinder, Mar 06 '16 at 21:44
@Foggy you are right, it is nicer without the RList, at least for this function — Sunny, Mar 06 '16 at 22:41
For learning purpose it is probably better to use a Discriminated Union for a list. Something like. `type MyList<'a> = | End | Cons of 'a * MyList<'a>` — David Raab, Mar 07 '16 at 04:48
As an exercise I wrote a function 'insert' without using the 'ref'. If you want, we can compare the result :) — FoggyFinder, Mar 08 '16 at 20:23
I tried to move my answer from the question to a new answer but I guess it didn't work. Not gonna question it. I've added it to the question now. @FoggyFinder — Sunny, Mar 09 '16 at 23:50

score 4 · Accepted Answer · answered Mar 06 '16 at 20:56

You return a bool from your None match:

| None -> list = cellToRList c

Equals sign is a comparison operator here. So the compiler infers the function to return bool, while I guess your intention is to return unit.

In any case, whenever you don't understand the inferred types of your functions, try annotating them explicitly. In your case, make it

let rec insert comp (item: int) (list: RList) : unit =

And you will see the problem that I described above.

You may want to remove type annotation once everything compiles.

That makes perfect sense now! Also FYI when I annotate it explicitly the compiler will find the error on the correct line. — Sunny, Mar 06 '16 at 21:06

f# linked list implementing with records

1 Answers1