F # todo liste utilisant des objets immuables

Question

J'essaie de comprendre comment faire une liste de tâches en F # en utilisant des objets immuables. La liste de tâches (pas nécessairement une liste F #) peut être tirée d'une base de données ou collectée à partir de l'entrée de l'utilisateur ou lire à partir de XML ou JSON, etc. Cette partie n'est pas si importante.

Pseudo Code:

do for some length of time: 
    for each item in the to do list: 
     if item is ready to do: 
     do item 
     if it worked: 
      remove from the todo list 

    wait a bit before trying again 
report on items that weren't ready or that failed. 

La liste à faire sera une collection de F # dossiers qui auront au moins une instruction (« Envoyer », « Lancer un processus », « Copier un fichier », "Demander une augmentation") avec des paramètres en tant que sous-collection.

Une telle chose peut-elle être faite avec des objets immuables seuls? Ou dois-je utiliser une liste .NET ou un autre objet modifiable?

Je n'ai pas besoin d'un code de travail complet, juste quelques idées sur la façon dont je pourrais mettre une telle chose ensemble.

MISE À JOUR: Première tentative (demi) codant cette chose:

let processtodo list waittime deadline = 
    let rec inner list newlist = 
     match list with 
     | [] when not List.isEmpty newlist -> 
       inner newlist [] 

     | head :: tail when head.isReady-> 
       let res = head.action 
       inner tail (if res = true then tail else list) 

     | head :: tail when not head.isReady -> 
       inner tail list 

     | _ when deadline not passed -> 
      // wait for the waittime 
      inner list 
     | _ -> report on unfinished list 

    inner list [] 

j'ai essayé d'écrire ce de la façon typique vu dans de nombreux exemples. J'ai supposé que les éléments supportent les méthodes "isReady" et "action". La chose que je n'aime pas est son appel récursif, donc consommera de l'espace de pile pour chaque récursion.

Answer 1

La récursivité et/ou les continuations sont des stratégies typiques pour transformer le code avec des structures mutables en boucles en structures immuables. Si vous savez écrire un "List.filter" récursif, alors vous aurez probablement quelques idées pour être sur la bonne voie.