Quali sono gli equivalenti funzionali delle dichiarazioni di interruzione imperativa e di altri controlli del ciclo?

Diciamo, ho la logica qui sotto. Come scriverlo in Programmazione funzionale?

    public int doSomeCalc(int[] array)
    {
        int answer = 0;
        if(array!=null)
        {
            for(int e: array)
            {
                answer += e;
                if(answer == 10) break;
                if(answer == 150) answer += 100;
            }
        }
        return answer;
    }

Gli esempi nella maggior parte dei blog, articoli ... Vedo solo che spiega il semplice caso di una funzione matematica diretta dire 'Somma'. Ma ho una logica simile a quella sopra scritta in Java e vorrei migrare a codice funzionale in Clojure. Se non possiamo fare quanto sopra in FP, allora il tipo di promozioni per FP non lo afferma esplicitamente.

So che il codice sopra è assolutamente imperativo. Non è stato scritto con la premessa di migrarlo in FP in futuro.

L'equivalente più vicino al loop su un array nella maggior parte dei linguaggi funzionali è una foldfunzione, ovvero una funzione che chiama una funzione specificata dall'utente per ciascun valore dell'array, passando un valore accumulato lungo la catena. In molti linguaggi funzionali, foldè ampliato da una varietà di funzioni aggiuntive che forniscono funzionalità extra, inclusa l'opzione di interruzione anticipata quando si presentano alcune condizioni. Nei linguaggi pigri (ad es. Haskell), fermarsi presto può essere raggiunto semplicemente non valutando ulteriormente l'elenco, il che farà sì che non vengano mai generati valori aggiuntivi. Pertanto, traducendo il tuo esempio in Haskell, lo scriverei come:

doSomeCalc :: [Int] -> Int
doSomeCalc values = foldr1 combine values
  where combine v1 v2 | v1 == 10  = v1
                      | v1 == 150 = v1 + 100 + v2
                      | otherwise = v1 + v2

Rompendo questa riga per riga nel caso in cui non si abbia familiarità con la sintassi di Haskell, questo funziona in questo modo:

doSomeCalc :: [Int] -> Int

Definisce il tipo di funzione, accettando un elenco di ints e restituendo un singolo int.

doSomeCalc values = foldr1 combine values

Il corpo principale della funzione: dato argomento values, return foldr1chiamato con argomenti combine(che definiremo di seguito) e values. foldr1è una variante della primitiva pieghevole che inizia con l'accumulatore impostato sul primo valore dell'elenco (quindi 1nel nome della funzione), quindi lo combina utilizzando la funzione specificata dall'utente da sinistra a destra (che di solito viene chiamata piega destra , da qui il rnome della funzione). Quindi foldr1 f [1,2,3]è equivalente a f 1 (f 2 3)(o f(1,f(2,3))nella sintassi C-like più convenzionale).

  where combine v1 v2 | v1 == 10  = v1

Definizione della combinefunzione locale: riceve due argomenti v1e v2. Quando v1è 10, ritorna e basta v1. In questo caso, v2 non viene mai valutato , quindi il ciclo si ferma qui.

                      | v1 == 150 = v1 + 100 + v2

In alternativa, quando v1 è 150, aggiunge un ulteriore 100 ad esso e aggiunge v2.

                      | otherwise = v1 + v2

E, se nessuna di queste condizioni è vera, aggiunge semplicemente v1 a v2.

Ora, questa soluzione è in qualche modo specifica per Haskell, perché il fatto che una piega a destra termina se la funzione di combinazione non valuta il suo secondo argomento è causato dalla strategia di valutazione pigra di Haskell. Non conosco Clojure, ma credo che utilizzi una valutazione rigorosa, quindi mi aspetto che abbia una foldfunzione nella sua libreria standard che includa un supporto specifico per la risoluzione anticipata. Questo è spesso chiamato foldWhile, foldUntilo simili.

Una rapida occhiata alla documentazione della biblioteca Clojure suggerisce che è un po 'diverso dalla maggior parte dei linguaggi funzionali nella denominazione e che foldnon è quello che stai cercando (è un meccanismo più avanzato volto a consentire il calcolo parallelo) ma reduceè il più diretto equivalente. La risoluzione anticipata si verifica se la reducedfunzione viene chiamata all'interno della funzione di combinazione. Non sono sicuro al 100% di capire la sintassi, ma sospetto che quello che stai cercando sia qualcosa del genere:

(reduce 
    (fn [v1 v2]
        (if (= v1 10) 
             (reduced v1)
             (+ v1 v2 (if (= v1 150) 100 0))))
    array)

NB: entrambe le traduzioni, Haskell e Clojure, non sono del tutto giuste per questo codice specifico; ma ne trasmettono il senso generale - vedi la discussione nei commenti qui sotto per problemi specifici con questi esempi.

Potresti facilmente convertirlo in ricorsione. E ha una bella chiamata ricorsiva ottimizzata per la coda.

Pseudocodice:

public int doSomeCalc(int[] array)
{
    return doSomeCalcInner(array, 0);
}

public int doSomeCalcInner(int[] array, int answer)
{
    if (array is empty) return answer;

    // not sure how to efficiently implement head/tails array split in clojure
    var head = array[0] // first element of array
    var tail = array[1..] // remainder of array

    answer += head;
    if (answer == 10) return answer;
    if (answer == 150) answer += 100;

    return doSomeCalcInner(tail, answer);
}

Mi piace molto la risposta di Jules , ma volevo anche sottolineare qualcosa che spesso manca alla programmazione pigra funzionale, ovvero che non tutto deve essere "all'interno del ciclo". Per esempio:

baseSums = scanl (+) 0

offsets = scanl (\offset sum -> if sum == 150 then offset + 100 else offset) 0

zipWithOffsets xs = zipWith (+) xs (offsets xs)

stopAt10 xs = if 10 `elem` xs then 10 else last xs

result = stopAt10 . zipWithOffsets . baseSums

result [1..]         -- 10
result [11..1000000] -- 500000499945

Puoi vedere che ogni parte della tua logica può essere calcolata in una funzione separata quindi composta insieme. Ciò consente funzioni più piccole che di solito sono molto più facili da risolvere. Per il tuo esempio di giocattolo, forse questo aggiunge più complessità di quanto non rimuova, ma nel codice del mondo reale le funzioni divise sono spesso molto più semplici del tutto.

La maggior parte degli esempi lista di elaborazione vedrete funzioni d'uso come map, filter, sumecc, che operano sulla lista nel suo complesso. Ma nel tuo caso hai un'uscita anticipata condizionale - un modello piuttosto insolito che non è supportato dalle normali operazioni dell'elenco. Quindi è necessario abbassare il livello di astrazione e utilizzare la ricorsione - che è anche più vicino a come appare l'esempio imperativo.

Questa è una traduzione piuttosto diretta (probabilmente non idiomatica) in Clojure:

(defn doSomeCalc 
  ([lst] (doSomeCalc lst 0))
  ([lst sum]
    (if (empty? lst) sum
        (if (= sum 10) sum
            (let [sum (+ sum (first lst))]
                 [sum (if (= sum 150) (+ sum 100) sum)]
               (recur (rest lst) sum))))))) 

Edit: punto di Jules che reducein Clojure fare supportare l'uscita anticipata. L'uso di questo è più elegante:

(defn doSomeCalc [lst]  
  (reduce (fn [sum val]
    (if (= sum 10) (reduced sum)
        (let [sum (+ sum val)]
             [sum (if (= sum 150) (+ sum 100) sum)]
           sum))
   lst)))

In ogni caso, puoi fare qualsiasi cosa nei linguaggi funzionali come puoi nei linguaggi imperativi, ma spesso devi cambiare un po 'la tua mentalità per trovare una soluzione elegante. Nella codifica imperativa pensi di elaborare un elenco passo dopo passo, mentre nei linguaggi funzionali cerchi un'operazione da applicare a tutti gli elementi dell'elenco.

Come sottolineato da altre risposte, Clojure deve reducedinterrompere anticipatamente le riduzioni:

(defn some-calc [coll]
  (reduce (fn [answer e]
            (let [answer (+ answer e)]
               (case answer
                 10  (reduced answer)
                 150 (+ answer 100)
                 answer)))
          0 coll))

Questa è la soluzione migliore per la tua situazione particolare. È inoltre possibile ottenere un sacco di chilometraggio dalla combinazione reducedcon transduce, che consente di utilizzare trasduttori da map, filterecc. Tuttavia, è tutt'altro che una risposta completa alla domanda generale.

Le continuazioni di escape sono una versione generalizzata di istruzioni break e return. Sono implementati direttamente in alcuni schemi ( call-with-escape-continuation), Common Lisp ( block+ return, catch+ throw) e persino in C ( setjmp+ longjmp). Continuazioni delimitate o non delimitate più generali come si trovano nello Schema standard o come monadi di continuazione in Haskell e Scala possono anche essere usate come continuazioni di fuga.

Ad esempio, in Racket potresti usare in let/ecquesto modo:

(define (some-calc ls)
  (let/ec break ; let break be an escape continuation
    (foldl (lambda (answer e)
             (let ([answer (+ answer e)])
               (case answer
                 [(10)  (break answer)] ; return answer immediately
                 [(150) (+ answer 100)]
                 [else  answer])))
           0 ls)))

Molte altre lingue hanno anche costrutti simili alla continuazione della fuga sotto forma di gestione delle eccezioni. In Haskell puoi anche usare una delle varie monadi con errori foldM. Poiché si tratta principalmente di costrutti per la gestione degli errori che utilizzano eccezioni o monadi di errore per i primi ritorni è generalmente inaccettabile dal punto di vista culturale e forse piuttosto lenta.

Puoi anche passare dalle funzioni di ordine superiore alle chiamate di coda.

Quando si utilizzano i loop, si immette automaticamente la successiva iterazione quando si raggiunge la fine del corpo del loop. È possibile immettere l'iterazione successiva in anticipo con continueo uscire dal ciclo con break(o return). Quando si utilizzano le chiamate di coda (o il loopcostrutto di Clojure che imita la ricorsione della coda), è sempre necessario effettuare una chiamata esplicita per inserire l'iterazione successiva. Per interrompere il loop non devi semplicemente effettuare la chiamata ricorsiva ma dare direttamente il valore:

(defn some-calc [coll]
  (loop [answer 0, [e es :as coll] coll]
    (if (empty? coll)
      answer
      (let [answer (+ answer e)]
        (case answer
          10 answer
          150 (recur (+ answer 100) es)
          (recur answer es))))))

La parte intricata è il ciclo. Cominciamo da quello. Un ciclo viene in genere convertito in stile funzionale esprimendo l'iterazione con una singola funzione. Un'iterazione è una trasformazione della variabile loop.

Ecco un'implementazione funzionale di un ciclo generale:

loop : v -> (v -> v) -> (v -> Bool) -> v
loop init iter cond_to_cont = 
    if cond_to_cont init 
        then loop (iter init) iter cond
        else init

Prende (un valore iniziale della variabile loop, la funzione che esprime una singola iterazione [sulla variabile loop]) (una condizione per continuare il ciclo).

Il tuo esempio usa un ciclo su un array, che si interrompe anche. Questa capacità nella tua lingua imperativa è inserita nella lingua stessa. Nella programmazione funzionale tale capacità è di solito implementata a livello di biblioteca. Ecco una possibile implementazione

module Array (foldlc) where

foldlc : v -> (v -> e -> v) -> (v -> Bool) -> Array e -> v
foldlc init iter cond_to_cont arr = 
    loop 
        (init, 0)
        (λ (val, next_pos) -> (iter val (at next_pos arr), next_pos + 1))
        (λ (val, next_pos) -> and (cond_to_cont val) (next_pos < size arr))

Dentro :

Uso una coppia ((val, next_pos)) che contiene la variabile loop visibile all'esterno e la posizione nell'array, che questa funzione nasconde.

La funzione di iterazione è leggermente più complessa rispetto al ciclo generale, questa versione consente di utilizzare l'elemento corrente dell'array. [È in forma al curry .]

Tali funzioni sono generalmente denominate "fold".

Metto una "l" nel nome per indicare che l'accumulo degli elementi dell'array è fatto in modo associativo sinistro; imitare l'abitudine dei linguaggi di programmazione imperativa di iterare un array dall'indice basso a quello alto.

Ho messo una "c" nel nome per indicare che questa versione di fold ha una condizione che controlla se e quando il ciclo deve essere fermato in anticipo.

Naturalmente è probabile che tali funzioni di utilità siano prontamente disponibili nella libreria di base fornita con il linguaggio di programmazione funzionale utilizzato. Li ho scritti qui per la dimostrazione.

Ora che abbiamo tutti gli strumenti che sono nella lingua nel caso imperativo, possiamo rivolgerci per implementare la funzionalità specifica del tuo esempio.

La variabile nel tuo ciclo è una coppia ('risposta', un valore booleano che codifica se continuare).

iter : (Int, Bool) -> Int -> (Int, Bool)
iter (answer, cont) collection_element = 
  let new_answer = answer + collection_element
  in case new_answer of
    10 -> (new_answer, false)
    150 -> (new_answer + 100, true)
    _ -> (new_answer, true)

Nota che ho usato una nuova "variabile" "new_answer". Questo perché nella programmazione funzionale non posso cambiare il valore di una "variabile" già inizializzata. Non mi preoccupo delle prestazioni, il compilatore potrebbe riutilizzare la memoria di "risposta" per "new_answer" tramite l'analisi del tempo di vita, se ritiene che sia più efficiente.

Incorporando questo nella nostra funzione loop sviluppata in precedenza:

doSomeCalc :: Array Int -> Int
doSomeCalc arr = fst (Array.foldlc (0, true) iter snd arr)

"Matrice" qui è il nome del modulo che è la funzione di esportazione foldlc.

"pugno", "secondo" indica funzioni che restituiscono il primo, secondo componente del suo parametro di coppia

fst : (x, y) -> x
snd : (x, y) -> y

In questo caso lo stile "senza punti" aumenta la leggibilità dell'implementazione di doSomeCalc:

doSomeCalc = Array.foldlc (0, true) iter snd >>> fst

(>>>) è la composizione della funzione: (>>>) : (a -> b) -> (b -> c) -> (a -> c)

È lo stesso di sopra, solo il parametro "arr" è escluso da entrambi i lati dell'equazione di definizione.

Un'ultima cosa: verificare il caso (array == null). In linguaggi di programmazione meglio progettati, ma anche in linguaggi mal progettati con una certa disciplina di base si usa piuttosto un tipo opzionale per esprimere la non esistenza. Questo non ha molto a che fare con la programmazione funzionale, di cui alla fine si tratta la domanda, quindi non me ne occupo.

Innanzitutto, riscrivi leggermente il ciclo, in modo tale che ogni iterazione del ciclo esca anticipatamente o muti answeresattamente una volta:

    public int doSomeCalc(int[] array)
    {
        int answer = 0;
        if(array!=null)
        {
            for(int e: array)
            {
                if(answer + e == 10) return answer + e;
                else if(answer + e == 150) answer = answer + e + 100;
                else answer = answer + e;
            }
        }
        return answer;
    }

Dovrebbe essere chiaro che il comportamento di questa versione è esattamente lo stesso di prima, ma ora è molto più semplice convertire in stile ricorsivo. Ecco una traduzione diretta di Haskell:

doSomeCalc :: [Int] -> Int
doSomeCalc = recurse 0
  where recurse :: Int -> [Int] -> Int
        recurse answer [] = answer
        recurse answer (e:array)
          | answer + e == 10 = answer + e
          | answer + e == 150 = recurse (answer + e + 100) array
          | otherwise = recurse (answer + e) array

Ora è puramente funzionale, ma possiamo migliorarlo sia dal punto di vista dell'efficienza che della leggibilità utilizzando una piega anziché una ricorsione esplicita:

import Control.Monad (foldM)

doSomeCalc :: [Int] -> Int
doSomeCalc = either id id . foldM go 0
  where go :: Int -> Int -> Either Int Int
        go answer e
          | answer + e == 10 = Left (answer + e)
          | answer + e == 150 = Right (answer + e + 100)
          | otherwise = Right (answer + e)

In questo contesto, Leftuscite anticipate con il suo valore eRight continua la ricorsione con il suo valore.

Questo ora potrebbe essere semplificato un po 'di più, in questo modo:

import Control.Monad (foldM)

doSomeCalc :: [Int] -> Int
doSomeCalc = either id id . foldM go 0
  where go :: Int -> Int -> Either Int Int
        go answer e
          | answer' == 10 = Left 10
          | answer' == 150 = Right 250
          | otherwise = Right answer'
          where answer' = answer + e

Questo è meglio come il codice Haskell finale, ma ora è un po 'meno chiaro come si associa alla Java originale.