Coding Practice for F #

Question

Mi sono dilettato con F # in Visual Studio 2010. Sono uno sviluppatore con più esperienza di progettazione di codice/architettura in linguaggi orientati agli oggetti come C# e Java.

Per espandere il mio set di competenze e aiutare a prendere decisioni migliori sto provando diverse lingue per fare cose diverse. In particolare, prendi il codice della codifica "correttamente" usando i linguaggi funzionali (in questo caso F #).

Un semplice esempio sta generando alcuni XML, quindi aggiungendo alcuni filtri per eliminare alcuni elementi.

Ecco il mio codice:

open System 
open System.Xml.Linq 


let ppl:(string * string) list = [ 
    ("1", "Jerry"); 
    ("2", "Max"); 
    ("3", "Andrew"); 
] 

/// Generates a Person XML Element, given a tuple. 
let createPerson (id:string, name:string) = new XElement(XName.Get("Person"), 
               new XAttribute(XName.Get("ID"), id), 
               new XElement(XName.Get("Name"), name) 
) 

/// Filter People by having odd ID's 
let oddFilter = fun (id:string, name:string) -> (System.Int32.Parse(id) % 2).Equals(1) 

/// Open filter which will return all people 
let allFilter = fun (id:string, name:string) -> true 

/// Generates a People XML Element. 
let createPeople filter = new XElement(XName.Get("People"), 
           ppl |> List.filter(filter) |> List.map createPerson 
) 

/// First XML Object 
let XmlA = createPeople oddFilter 

/// Second XML Object 
let XmlB = createPeople allFilter 


printf "%A\n\n%A" XmlA XmlB 


/// Waits for a keypress 
let pauseKey = fun() -> System.Console.ReadKey() |> ignore 


pauseKey() 

Le mie domande sono: Quali sono le cose ho fatto bene in questo scenario? Quali parti potrebbero essere fatte meglio?

Non vedo davvero l'ora di alcune idee e sono abbastanza entusiasta di conoscere anche i paradigmi funzionali! :)

Grazie in anticipo

Answer 1

In linea di principio, il codice è tutto a posto.

Ci sono solo alcuni punti che possono essere semplificati da un punto di vista sintattico.

let ppl:(string * string) list = [ 
    ("1", "Jerry"); 
    ("2", "Max"); 
    ("3", "Andrew"); 
] 

Il compilatore è in grado di dedurre maggior parte dei tipi da lui stesso:

let ppl = [ "1", "Jerry"; 
      "2", "Max"; 
      "3", "Andrew" ] 

E naturalmente è possibile ri-scrivere i filtri come questo a causa di currying:

let oddFilter (id:string, name:string) = (int id) % 2 = 1 
let allFilter (id:string, name:string) = true 

Il più grande il miglioramento sarebbe la separazione degli indici dai nomi e lasciare che il programma esegua la numerazione.Non è necessario lavorare con le stringhe al posto dei numeri e può utilizzare più idiomatiche funzioni senza parametri:

let ppl = [ "Jerry"; "Max"; "Andrew" ] 

let oddFilter id name = id % 2 = 1 
let allFilter id name = true 

let createPerson id name = ... 

La parte

ppl |> List.filter(filter) |> List.map createPerson 

sarebbe riscritto per

[ for (index, name) in List.mapi (fun i x -> (i, x)) do 
     if filter index name then 
      yield createPerson (string index) name ] 

Answer 2

let createPeople filter = new XElement(XName.Get("People"), 
          ppl |> List.filter(filter) |> List.map createPerson 
) 

Questa parte può essere deforested manualmente, oppure è possibile sperare che il compilatore deforest per voi.

Fondamentalmente, c'è una struttura intermedia (la lista delle persone filtrate) che, se questa è compilata in modo ingenuo, sarà assegnata a servire una sola volta. Meglio applicare createPerson su ciascun elemento, in quanto è deciso se sono dentro o fuori e creare direttamente il risultato finale.

EDIT: cfern contribuito questa versione disboscata di createPeople:

let createPeople filter = 
    new XElement(
    XName.Get("People"), 
    List.foldBack 
     (fun P acc -> if filter P then (createPerson P)::acc else acc) 
     ppl 
     []) 

NOTA: perché ci potrebbero essere effetti collaterali a filter o createPerson, in F # è piuttosto difficile per il compilatore di decidere a disboscare da si. In questo caso mi sembra che la deforestazione sia corretta perché anche se lo filter ha effetti collaterali, non lo è lo createPerson, ma non sono uno specialista.

Answer 3

Most del tempo che deforestazione senza una ragione specifica, generalmente prestazioni, è una cattiva idea. Quale di questi ritieni più facile da leggere e meno incline agli errori? La deforestazione presa fuori dal contesto aggiunge solo complessità e/o accoppiamento al codice.

let createPeople filter ppl = 
    ppl 
    |> List.mapi (fun i x -> (i, x)) 
    |> List.filter filter 
    |> List.map createPerson 

let createPeople filter ppl = 
    [ for (index, name) in ppl |> List.mapi (fun i x -> (i, x)) do 
      if filter (index, name) then 
       yield createPerson (index, string) ] 

let createPeople filter ppl = 
    (ppl |> List.mapi (fun i x -> (i, x)), []) 
    ||> List.foldBack (fun P acc -> if filter P then (createPerson P)::acc else acc) 

volta ci si abitua alla composizione funzione di sintassi consente di escludere ppl.

let createPeople filter = 
    List.mapi (fun i x -> (i, x)) 
    >> List.filter filter 
    >> List.map createPerson 

Tutti utilizzano dati tupla.

let filter (id, name) = 
    id % 2 = 1 

let allFilter (id, name) = 
    true 

let createPerson (id, name) = 
    () 

Answer 4

Ho anche recentemente avuto bisogno di trasformare un XSL in un file XML. Questa è la F # che ho usato per fare questo.

Ha alcune peculiarità interessanti nell'usare i metodi .net.

(* Transforms an XML document given an XSLT. *) 

open System.IO 
open System.Text 
open System.Xml 
open System.Xml.Xsl 

let path = @"C:\\XSL\\" 

let file_xml = path + "test.xml" 
let file_xsl = path + "xml-to-xhtml.xsl" 

(* Compile XSL file to allow transforms *) 
let compile_xsl (xsl_file:string) = new XslCompiledTransform() |> (fun compiled -> compiled.Load(xsl_file); compiled) 
let load_xml (xml_file:string) = new XmlDocument() |> (fun doc -> doc.Load(xml_file); doc) 

(* Transform an Xml document given an XSL (compiled *) 
let transform (xsl_file:string) (xml_file:string) = 
     new MemoryStream() 
     |> (fun mem -> (compile_xsl xsl_file).Transform((load_xml xml_file), new XmlTextWriter(mem, Encoding.UTF8)); mem) 
     |> (fun mem -> mem.Position <- (int64)0; mem.ToArray()) 

(* Return an Xml fo document that has been transformed *) 
transform file_xsl file_xml 
    |> (fun bytes -> File.WriteAllBytes(path + "out.html", bytes))