Comment créer une CLI TODO en F# en 2026

dotnet new console -lang F# -o TodoCli
cd TodoCli
dotnet tool install --global dotnet-fantomas  # Outil de formatage F# (optionnel mais recommandé)
dotnet add package System.Text.Json --version 8.0.5
code .

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>preview</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.Text.Json" Version="8.0.5" />
  </ItemGroup>

</Project>

namespace TodoCli

/// ID unique d'une tâche (entier positif)
type TaskId = int

/// Statut d'une tâche
[<RequireQualifiedAccess>]
type TaskStatus =
    | Pending
    | Done

/// Tâche TODO immutable
[<Struct>]
type TodoTask = {
    Id: TaskId
    Description: string
    Status: TaskStatus
} with

    /// Nouveau ID auto-incrémenté
    static member Create(description: string) : TodoTask =
        { Id = 0; Description = description; Status = TaskStatus.Pending }

/// Commandes CLI supportées
type Command =
    | Add of description: string
    | List
    | Complete of TaskId
    | Quit
    | Unknown of string

namespace TodoCli

open System
open Types

/// Type sûr pour les erreurs CLI
type CliError = string

/// Parse une ligne en Command ou erreur
let parseCommand (line: string) : Result<Command, CliError> =
    let words = line.Trim().Split([| ' ' |], StringSplitOptions.RemoveEmptyEntries)
    match Array.toList words with
    | [] -> Error "Commande vide. Tapez 'help' pour l'aide."
    | "add" :: description ->
        if List.isEmpty description then
            Error "Description manquante après 'add'"
        else
            Ok (Add (String.concat " " description))
    | "list" -> Ok List
    | "complete" :: idStr :: _ ->
        match Int32.TryParse idStr with
        | true, id when id > 0 -> Ok (Complete id)
        | _ -> Error "ID invalide après 'complete'"
    | "quit" -> Ok Quit
    | "help" -> printfn "Commandes: add <desc>, list, complete <id>, quit"; Error "Aide affichée"
    | _ -> Error (sprintf "Commande inconnue: %s" line)

/// État global : liste de tâches avec nextId
[<Struct>]
type TodoState = {
    Tasks: TodoTask list
    NextId: TaskId
}

let initialState: TodoState = { Tasks = []; NextId = 1 }

/// Ajoute une tâche
let addTask state desc : TodoState =
    let task = { TodoTask.Create desc with Id = state.NextId }
    { state with Tasks = task :: state.Tasks; NextId = state.NextId + 1 }

/// Liste les tâches formatées
let listTasks (state: TodoState) : unit =
    if List.isEmpty state.Tasks then
        printfn "Aucune tâche."
    else
        state.Tasks
        |> List.sortByDescending (fun t -> t.Id)
        |> List.iteri (fun i t ->
            let status = if t.Status = TaskStatus.Done then "[✓]" else "[ ]"
            printfn " %d: %s %s" t.Id status t.Description)

/// Complète une tâche par ID
let completeTask state id : Result<TodoState, CliError> =
    match state.Tasks |> List.tryFind (fun t -> t.Id = id) with
    | None -> Error (sprintf "Tâche %d introuvable" id)
    | Some task ->
        let updated = { task with Status = TaskStatus.Done }
        let newTasks = state.Tasks |> List.map (fun t -> if t.Id = id then updated else t)
        Ok { state with Tasks = newTasks }

open System.Text.Json
open System.IO

let dataFile = "todo.json"

let saveStateAsync (state: TodoState) : Async<unit> =
    async {
        let json = JsonSerializer.Serialize(state, JsonSerializerOptions())
        do! File.WriteAllTextAsync(dataFile, json)
    }

let loadStateAsync () : Async<TodoState> =
    async {
        if File.Exists dataFile then
            let! json = File.ReadAllTextAsync(dataFile)
            return JsonSerializer.Deserialize<TodoState>(json, JsonSerializerOptions()) |> Option.defaultValue initialState
        else
            return initialState
    }

namespace TodoCli

open System
open Commands

[<EntryPoint>]
let main argv =
    task {
        let! state = loadStateAsync()
        let mutable currentState = state

        printfn "=== CLI TODO F# ==="
        printfn "Tapez 'help' pour l'aide."

        while true do
            printf "todo> "
            let line = Console.ReadLine()
            if isNull line then () else
                match parseCommand line with
                | Error msg -> printfn "Erreur: %s" msg
                | Ok cmd ->
                    match cmd with
                    | Quit -> do! saveStateAsync currentState; printfn "Au revoir!"; return 0
                    | List -> listTasks currentState
                    | Add desc -> currentState <- addTask currentState desc; do! saveStateAsync currentState
                    | Complete id -> 
                        match completeTask currentState id with
                        | Ok newState -> currentState <- newState; do! saveStateAsync currentState
                        | Error msg -> printfn "Erreur: %s" msg

        return 0
    } |> Async.StartAsTask |> ignore

    0

cd TodoCli
dotnet build
dotnet run
# Test:
# add Acheter du lait
# list
# complete 1
# quit