Molte delle altre risposte si sono concentrate sul lato prestazionale (parallelismo) della programmazione funzionale, che credo sia molto importante. Tuttavia, hai chiesto in modo specifico la produttività, come in, puoi programmare la stessa cosa più velocemente in un paradigma funzionale che in un paradigma imperativo.
In realtà trovo (per esperienza personale) che la programmazione in F # corrisponda al modo in cui penso meglio, quindi è più facile. Penso che sia la differenza più grande. Ho programmato sia in F # che in C #, e c'è molto meno "combattere la lingua" in F #, che adoro. Non devi pensare ai dettagli in F #. Ecco alcuni esempi di ciò che ho scoperto che mi piace molto.
Ad esempio, anche se F # è tipizzato staticamente (tutti i tipi vengono risolti in fase di compilazione), l'inferenza del tipo determina quali tipi hai, quindi non devi dirlo. E se non riesce a capirlo, rende automaticamente la tua funzione / classe / qualunque cosa generica. Quindi non devi mai scrivere alcun generico, è tutto automatico. Trovo che ciò significhi che sto spendendo più tempo a pensare al problema e meno a come implementarlo. In effetti, ogni volta che torno a C #, trovo che mi manca davvero questa inferenza di tipo, non ti rendi mai conto di quanto sia fastidioso fino a quando non devi più farlo.
Anche in F #, invece di scrivere loop, chiamate funzioni. È un cambiamento sottile, ma significativo, perché non devi più pensare al costrutto del ciclo. Ad esempio, ecco un pezzo di codice che passa attraverso e abbina qualcosa (non ricordo cosa, proviene da un puzzle di Eulero del progetto):
let matchingFactors =
factors
|> Seq.filter (fun x -> largestPalindrome % x = 0)
|> Seq.map (fun x -> (x, largestPalindrome / x))
Mi rendo conto che fare un filtro quindi una mappa (che è una conversione di ogni elemento) in C # sarebbe abbastanza semplice, ma devi pensare a un livello inferiore. In particolare, dovresti scrivere il ciclo stesso e avere la tua istruzione if esplicita e quel tipo di cose. Da quando ho imparato F #, mi sono reso conto che ho trovato più facile programmare in modo funzionale, dove se vuoi filtrare, scrivi "filter", e se vuoi mappare, scrivi "map", invece di implementare ciascuno dei dettagli.
Adoro anche l'operatore |>, che secondo me separa F # da ocaml, e probabilmente altri linguaggi funzionali. È l'operatore pipe, ti permette di "pipe" l'output di un'espressione nell'input di un'altra espressione. Fa seguire il codice come penso di più. Come nello snippet di codice sopra, si dice "prendi la sequenza dei fattori, filtrala, quindi mappala". È un livello molto alto di pensiero, che non si ottiene in un linguaggio di programmazione imperativo perché sei così impegnato a scrivere il ciclo e le dichiarazioni if. È l'unica cosa che mi manca di più ogni volta che vado in un'altra lingua.
Quindi, in generale, anche se posso programmare sia in C # che in F #, trovo più facile usare F # perché si può pensare a un livello superiore. Direi che, poiché i dettagli più piccoli vengono rimossi dalla programmazione funzionale (almeno in F #), sono più produttivo.
Modifica : ho visto in uno dei commenti che hai chiesto un esempio di "stato" in un linguaggio di programmazione funzionale. F # può essere scritto in modo imperativo, quindi ecco un esempio diretto di come puoi avere uno stato mutabile in F #:
let mutable x = 5
for i in 1..10 do
x <- x + i