Что правильный путь состоит в том, чтобы сделать изменяемые структуры данных (например, пропустите списки, вывихните деревья) в F#?

Что хороший путь состоит в том, чтобы реализовать изменяемые структуры данных в F#? Причина, которую я спрашиваю, состоит в том, потому что я хочу возвратиться и реализовать структуры данных, о которых я узнал в уроке алгоритмов, который я посещал в этом семестре (пропустите списки, вывихните деревья, деревья сплава, y-fast попытки, деревья van Emde Boas, и т.д.), который был чистым курсом теории без кодирования вообще, и я полагаю, что мог бы также попытаться изучить F#, в то время как я делаю его. Я знаю, что "должен" использовать деревья пальца для получения косой древовидной функциональности на функциональном языке, и что я должен сделать что-то с ленью для получения функциональности списка пропуска, и т.д., но я хочу закрепить основы, прежде чем я попытаюсь играть с чисто функциональными реализациями.

Существует много примеров того, как сделать функциональные структуры данных в F#, но нет очень о том, как сделать изменяемые структуры данных, таким образом, я запустил путем согласовывания двунаправленного связанного списка здесь во что-то, что позволяет, вставляет и удаляет где угодно. Мой план состоит в том, чтобы превратить это в список пропуска и затем использовать подобную структуру (дизъюнктное объединение записи) для древовидных структур, которые я хочу реализовать. Прежде чем я запущу на чем-то более существенном, существует ли лучший способ сделать изменяемые структуры как это в F#? Я должен просто использовать записи и не обеспокоиться дизъюнктным объединением? Я должен использовать класс вместо этого? Этот вопрос "даже неправильно"? Я должен делать изменяемые структуры в C# и не падение в F#, пока я не хочу сравнить их с их чисто функциональными дубликатами?

И, если DU записей - то, что я хочу, я, возможно, написал код ниже лучше или более идиоматически? Кажется, что существует большое дублирование здесь, но я не уверен, как избавиться от него.

module DoublyLinkedList =
    type 'a ll  = 
        | None
        | Node of 'a ll_node
    and 'a ll_node = {
        mutable Prev: 'a ll;
        Element : 'a ;
        mutable Next: 'a ll;
    }

    let insert x l = 
        match l with 
        | None -> Node({ Prev=None; Element=x; Next=None })
        | Node(node) ->
            match node.Prev with
                | None -> 
                    let new_node = { Prev=None; Element=x; Next=Node(node)}
                    node.Prev <- Node(new_node)
                    Node(new_node)
                | Node(prev_node) -> 
                    let new_node = { Prev=node.Prev; Element=x; Next=Node(node)}
                    node.Prev <- Node(new_node)
                    prev_node.Next <- Node(new_node)
                    Node(prev_node)

    let rec nth n l =
        match n, l with
        | _,None -> None
        | _,Node(node) when n > 0 -> nth (n-1) node.Next 
        | _,Node(node) when n < 0 -> nth (n+1) node.Prev 
        | _,Node(node) -> Node(node) //hopefully only when n = 0 :-)

    let rec printLinkedList head = 
        match head with
        | None -> ()
        | Node(x) -> 
            let prev = match x.Prev with
                        | None -> "-"
                        | Node(y) -> y.Element.ToString()
            let cur = x.Element.ToString()
            let next = match x.Next with
                        | None -> "-"
                        | Node(y) -> y.Element.ToString()
            printfn "%s, <- %s -> %s" prev cur next
            printLinkedList x.Next