F # Immuable structure variable de données de fenêtre de taille

Question

J'ai ci-dessous une description d'une structure de données dont j'ai besoin et je veux la mettre en œuvre en utilisant des structures de données immuables. J'essaie de déterminer ... existe-t-il une structure de données existante qui soutiendra ce que j'essaie de faire ici ou dois-je en créer un - et si j'ai besoin de le créer, quel serait un bon endroit pour commencer (blocs de construction)?

---

J'ai un flux continu de valeurs entrantes d'un certain type. Je veux les ajouter à une structure de données persistante/immuable pour en contenir un historique, et à chaque ajout, il passera en revue l'historique et déterminera si un ou plusieurs éléments plus anciens seront supprimés (par exemple, si l'historique est> un certaine longueur ou une valeur a une certaine propriété).

Answer 1

Sans savoir plus sur vos besoins, je dirais simplement vanille Set<'a> fait un plus que le travail adéquat. Je préfère un 'Set' sur une 'Liste' afin que vous ayez toujours accès aux plus grands et petits objets, vous permettant de commander votre ensemble en insérant la date/heure pour un accès efficace aux éléments les plus récents et les plus anciens .

semble très facile à conclure un ensemble de sorte que ses Ajout/Suppression de méthodes invoquer votre callbacks:

type AwesomeSet(internalSet : Set<'a>, insertCallback : 'a -> unit, removeCallback : 'a -> unit) = 
    member this.Add(x) = 
     insertCallback(x) 
     AwesomeSet(internalSet.Add x, insertCallback, removeCallback) 

    member this.Remove(x) = 
     removeCallback(x) 
     AwesomeSet(internalSet.Remove x, insertCallback, removeCallback) 

    member this.Count = internalSet.Count 
    member this.Min = internalSet.MinimumElement 
    member this.Max = internalSet.MaximumElement 

Answer 2

Merci à l'information genre de Juliette, je l'ai mis en œuvre ce que je dois et je l'ai mis ici au cas où quelqu'un d'autres pourraient le trouver utile.

let rec removeLast (s : Set<'a>, num : int) : Set<'a> = 
    match num with 
    | 0 -> s 
    | _ -> removeLast(s.Remove(s.MinimumElement), num-1) 


type History<'a when 'a : comparison>(underlying : Set<'a>, removal : History<'a> -> int) = 
    member this.Add(x) = 
     History(removeLast(underlying, removal(this)).Add x, removal) 

    member this.Count = underlying.Count 
    member this.Min = underlying.MinimumElement 
    member this.Max = underlying.MaximumElement 
    member this.Under = underlying 

let maxHist = 2 
let maxCountRemover (h : History<int>) = 
    if h.Count >= maxHist 
    then h.Count - maxHist + 1 
    else 0 


let testHistory = 
    let s = History(Set.empty, r) 
    let s = s.Add(1); 
    printfn "%i: %i - %i" s.Count s.Min s.Max 
    let s = s.Add(2); 
    printfn "%i: %i - %i" s.Count s.Min s.Max 
    let s = s.Add(3); 
    printfn "%i: %i - %i" s.Count s.Min s.Max 
    let s = s.Add(4); 
    printfn "%i: %i - %i" s.Count s.Min s.Max 
    let s = s.Add(5); 
    printfn "%i: %i - %i" s.Count s.Min s.Max 
    printfn "%A" s.Under