Dividere un file in più oggetti in modo funzionale

Se l'intero file è abbastanza piccolo da adattarsi alla memoria, allora penso che un modo sarebbe quello di analizzare il file in una lista e quindi elaborare l'elenco pezzo per pezzo, qualcosa del tipo:

let parseItem (columnsString::rowsString::rest) =
    let columns = int columnsString
    let rows = int rowsString
    let position, rest = parsePosition rest
    let calibration, rest = parseCalibration rest
    let points, rest = parsePoints columns rows rest
    (columns, rows, position, calibration, points), rest

let rec parseItems = function
    | [] -> []
    | lines ->
        let item, restLines = parseItem lines
        let restItems = parseItems restLines
        item :: restItems

Come hai sicuramente notato, questo codice è piuttosto ripetitivo, ma puoi semplificarlo usando il flusso di lavoro dello stato (noto come monade di stato in Haskell) da ExtCore :

let parseItem =
    state {
        let! columns = parseInt
        let! rows = parseInt
        let! position = parsePosition
        let! calibration = parseCalibration
        let! points = parsePoints columns rows
        return columns, rows, position, calibration, points
    }

let rec parseItems = function
    | [] -> [], []
    | lines ->
        state {
            let! item = parseItem
            let! restItems = parseItems
            return item::restItems
        } <| lines

Scommetto che lo strumento più popolare nel mondo Haskell per questo tipo di problema è combinatori di parser . La libreria classica per questo è parsec , ma per un formato di file generato dalla macchina il attoparsec è in genere una scelta migliore (analisi più veloce a costo di una segnalazione di errori meno amichevole, un buon compromesso quando si leggono file di grandi dimensioni che non sono stati scritti dagli umani) .

C'è un eccellente tutorial che dimostra l'uso di attoparsec dal log di analisi file .

Attoparsec è abbastanza popolare che qualcuno ha provato a portarlo su F # , ma non ho mai nemmeno scritto un programma F #, quindi Sicuramente non ho modo di giudicare la qualità di quella libreria. C'è anche una porta della libreria regolare (non "atto") di Haskell su F # , che potrebbe valere la pena guardare viene fornito anche con un tutorial .

Se desideri comprendere un po 'come i parser combinatori funzionano sotto il cofano, Graham Hutton e Erik Meijer hanno scritto due semplici tutorial che mostrano gli interni semplificati. Il primo, credo, è una versione ridotta del secondo:

• link
• link

Questi sono in Haskell, ma se conosci F # probabilmente sarai in grado di seguirne molto.

Questo non è esattamente uno dei migliori casi di utilizzo della programmazione funzionale, ma la maggior parte dei linguaggi ha un costrutto che creerà un flusso infinito di linee, che generalmente si alimentano in fold con uno stato iniziale. Ecco un esempio in Scala (mi dispiace, non so F #):

val lines = io.Source.stdin.getLines
val state = lines.foldLeft(initialState)(processLine)

Fondamentalmente, la funzione processLine è qualsiasi cosa tu inseriresti nel tuo ciclo while , e restituisce ogni volta un nuovo stato. Al suo interno, puoi usare split , regex, pattern matching o anche parser combinatori se sei coraggioso.

Non posso affermare che la soluzione funzionale finisca più elegante con qualcosa di questo stato, ma ha il vantaggio che il percorso sbagliato di solito è ovvio abbastanza rapidamente.