Problemi di comprensione del funzionamento della ricorsione tupla in Haskell

Question

Non riesco a capire come funziona questa funzione. La funzione dovrebbe prendere una stringa e dividere quella stringa in una coppia, di cui il primo elemento è la prima 'parola' che si trova nella stringa e il secondo elemento è il resto della stringa di input. In particolare, nella riga 6, capisco perché la funzione debba terminare quando isSpace c è vera, ma non capisco perché dovrebbe restituire una tupla con il primo elemento che è la lista vuota. Mi chiedevo se qualcuno potesse spiegare perché questo funziona con un esempio relativamente semplice (ma non banale) come nextWord "an apple".

import Data.Char 
nextWord :: String -> (String, String) 
nextWord [] 
    = ([],[]) 
nextWord (c:cs) 
    | isSpace c = ([], cs) 
    | otherwise = (c: word, other) 
    where 
    (word, other) = nextWord cs 

EDIT: Come esempio di ciò che questa funzione restituisce quando l'argomento data inizia con uno spazio, NextWord "ciao" deve restituire ("", "ciao").

Answer 1

Facciamolo!

nextWord "an apple" 

Dal "an apple" non lo fa pattern match contro [], siamo nel secondo caso. Sostituendo in 'a': "n apple" per c : cs, otteniamo:

nextWord ('a':"n apple") 
    | isSpace 'a' = ([], "n apple") 
    | otherwise = ('a': word, other) 
    where 
    (word, other) = nextWord "n apple" 

isSpace 'a' è False, in modo che si semplifica come

nextWord ('a':"n apple") = ('a': word, other) 
    where (word, other) = nextWord "n apple" 

Allo stesso modo, per nextWord "n apple" otteniamo

nextWord ('n':" apple") = ('n': word, other) 
    where (word, other) = nextWord " apple" 

E per nextWord " apple" otteniamo

nextWord (' ':"apple") 
    | isSpace ' ' = ([], "apple") 
    | otherwise = ('a': word, other) 
    where 
    (word, other) = nextWord "n apple" 

che semplifica al

nextWord (' ':"apple") = ([], "apple") 

Sostituendo indietro nella nostra espressione per nextWord "n apple", otteniamo

nextWord ('n':" apple") = ('n': word, other) 
    where (word, other) = ([], "apple") 

che semplifica al

nextWord ('n':" apple") = ('n':[], "apple") 

o

nextWord ('n':" apple") = ("n", "apple") 

Ora sostituendo che indietro nella nostra espressione per nextWord "an apple", otteniamo

nextWord ('a':"n apple") = ('a': word, other) 
    where (word, other) = ("n", "apple") 

che semplifica al

nextWord ('a':"n apple") = ('a':"n", "apple") 

o

nextWord ('a':"n apple") = ("an", "apple")