Pratique F# extraits

Il y a déjà deux questions F#/fonctionnelle des extraits.

Cependant, ce que je cherche ici sont utile extraits, peu 'helper' fonctions qui sont réutilisables. Ou obscur mais astucieux des modèles que vous ne pouvez jamais me rappeler.

Quelque chose comme:

open System.IO

let rec visitor dir filter= 
    seq { yield! Directory.GetFiles(dir, filter)
          for subdir in Directory.GetDirectories(dir) do 
              yield! visitor subdir filter}

Je voudrais faire une sorte de pratique de page de référence. En tant que tel il n'y aura pas de bonne réponse, mais j'espère que beaucoup de ceux qui sont bons.

MODIFIER Tomas Petricek a créé un site spécialement pour les F# extraits de http://fssnip.net/.

  • S'il vous plaît faire un wiki de la communauté.
  • Fait, je croyais que le départ comme une question normale peut fournir la motivation pour certaines réponses initiales.
InformationsquelleAutor |
  1. 27

    De style Perl regex correspondant

    let (=~) input pattern =
    System.Text.RegularExpressions.Regex.IsMatch(input, pattern)

    Il vous permet d'adapter le texte à l'aide de let test = "monkey" =~ "monk.+" notation.

    InformationsquelleAutor
  2. 27

    Opérateur Infixe

    Je l'ai obtenu à partir de http://sandersn.com/blog//index.php/2009/10/22/infix-function-trick-for-f aller à cette page pour plus de détails.

    Si vous connaissez Haskell, vous pourriez vous retrouver manquant infix de sucre en F#:

    //standard Haskell call has function first, then args just like F#. So obviously
//here there is a function that takes two strings: string -> string -> string 
startsWith "kevin" "k"

//Haskell infix operator via backQuotes. Sometimes makes a function read better.
"kevin" `startsWith` "K"

    Alors que F# ne pas avoir un "vrai" infixe "opérateur, la même chose peut être accompli presque avec autant d'élégance via un pipeline et d'un "backpipeline" (qui savait une chose pareille??)

    //F# 'infix' trick via pipelines
"kevin" |> startsWith <| "K"
    • +1: je ne sais pas pourquoi, mais cela m'a fait lulz 🙂
    • Moi aussi, mais je pense que je sais pourquoi. Se souvient d'une image. (ne pas poster ici, c'est NSFW)
    InformationsquelleAutor
  3. 26

    Multi-Ligne De Chaînes

    C'est assez trivial, mais il semble être une caractéristique de F# chaînes qui n'est pas très connu.

    let sql = "select a,b,c \
           from table \
           where a = 1"

    Ce produit:

    val sql : string = "select a,b,c from table where a = 1"

    Lorsque le compilateur F# voit un antislash suivi d'un retour chariot à l'intérieur d'une chaîne de caractères littérale, il va supprimer tout le back-slash pour le premier caractère non espace sur la ligne suivante. Cela vous permet d'avoir plusieurs lignes littéraux de chaîne de cette ligne, sans l'aide d'un tas de concaténation de chaîne.

    • Maintenant, que est cool.
    • Juste pour ajouter à cela, C# style @"chaîne" fonctionne avec multiligne en F#, trop!
    • FYI de l'avenir. Vous n'avez pas besoin de barres obliques inverses plus.
    • merci pour l'astuce, mais pouvez-vous être précis quant avenir, vous êtes à partir de? Je l'ai juste essayé en F# 3.1, VS 2013, et vous n'avez encore besoin de les barres obliques, si vous voulez les espaces au début de chaque ligne pour être dépouillé de la chaîne résultante dans cette version.
    • Multi-ligne littéraux de chaîne sans les barres obliques inverses ne pas couper les sauts de ligne et les espaces de début de la chaîne (test en F# 4.0)
    InformationsquelleAutor
  4. 24

    Générique memoization, avec l'aimable autorisation de l'homme lui-même

    let memoize f = 
  let cache = System.Collections.Generic.Dictionary<_,_>(HashIdentity.Structural)
  fun x ->
    let ok, res = cache.TryGetValue(x)
    if ok then res
    else let res = f x
         cache.[x] <- res
         res

    En utilisant cela, vous pourriez faire un cache de lecteur comme suit:

    let cachedReader = memoize reader
    • Vous devriez passer HashIdentity.Structural à Dictionary ou elle va utiliser la valeur par défaut .NETTE de référence de l'égalité sur les touches au lieu de F#'s l'égalité structurelle.
    • .NET aime à comparer les valeurs par référence alors que F# compare les valeurs structurellement (c'est à dire en fonction de leur contenu). Donc, de deux tableaux [|2|] et [|2|] ne sont pas égaux selon .NET mais sont égales en fonction de F#. Si de telles valeurs se posent comme des "x" dans votre code, il va produire des résultats inattendus pour un F# programmeur. Ceci est décrit dans mes livres, bien sûr.
    • Harrop Ne le dict opérateur de faire cela?
    • Riley: Si vous ne dict [[|1|], 2; [|1|], 4] ensuite, vous obtenez un seul de liaison avec la clé [|1|] qui démontre que c'est en effet à l'aide structurelle de hachage, oui.
    • Je voudrais améliorer cette memoization fonction pour la rendre plus sûre. Si une victime de l'union a été réglé pour avoir une valeur null compilation représentation il va se planter au moment de l'exécution si vous ne l'ont jamais été pour l'insertion de ce cas comme une clé. Je voudrais donc envelopper la clé dans le type d'option avant de la persistance.
    InformationsquelleAutor
  5. 18

    Simple lecture-écriture pour les fichiers texte

    Ces sont triviales, mais de faire de l'accès au fichier de pipeable:

    open System.IO
let fileread f = File.ReadAllText(f)
let filewrite f s = File.WriteAllText(f, s)
let filereadlines f = File.ReadAllLines(f)
let filewritelines f ar = File.WriteAllLines(f, ar)

    Donc

    let replace f (r:string) (s:string) = s.Replace(f, r)

"C:\\Test.txt" |>
    fileread |>
    replace "teh" "the" |>
    filewrite "C:\\Test.txt"

    Et de la combiner avec le visiteur de cité dans la question:

    let filereplace find repl path = 
    path |> fileread |> replace find repl |> filewrite path

let recurseReplace root filter find repl = 
    visitor root filter |> Seq.iter (filereplace find repl)

    Mise à jour Légère amélioration, si vous voulez être en mesure de lire les fichiers verrouillés (par exemple, fichiers csv qui sont déjà ouverts dans Excel...):

    let safereadall f = 
   use fs = new FileStream(f, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
   use sr = new StreamReader(fs, System.Text.Encoding.Default)
   sr.ReadToEnd()

let split sep (s:string) = System.Text.RegularExpressions.Regex.Split(s, sep)

let fileread f = safereadall f
let filereadlines f = f |> safereadall |> split System.Environment.NewLine
    • Vous pouvez transférer des Fichiers.ReadAllLines, elle retourne un Tableau... par exemple de Fichier.ReadAllLines(fichier) |> Array.carte print_line
    • Je voudrais voir quelques exemples d'utilisation de ces que je suis très nouveau...spécifiquement destiné à le début "make file access pipeable:"
    • Confondu par celui-ci, depuis toutes ces méthodes de Fichier pipeline très bien sans l'aliasing. par exemple, "C:\\somefile.txt" |> Fichier.ReadAllText
    • seulement ceux avec un seul paramètre. l'aliasing un paramètre rend les choses moins lop-verso (pour moi).
    InformationsquelleAutor
  6. 17

    Pour la performance intensive des trucs où vous en avez besoin pour vérifier la valeur null

    let inline isNull o = System.Object.ReferenceEquals(o, null)
if isNull o then ... else ...

    Est d'environ 20x plus vite alors 

    if o = null then ... else ...
    • Notez également que o = null nécessite la Equality contrainte si vous travaillez avec les génériques
    • OMG! Pourquoi il y a une telle différence?
    • Parce que le premier se traduit par une simple référence de comparaison, tandis que les autres appels FSharp.De base.LanguagePrimitives.HashCompare.GenericEqualityIntrinsic, ce qui est beaucoup plus de code.
    • Remarque, dans le F# 4.0, le isNull est maintenant un standard inline opérateur et FSharpLint la gentillesse de se plaindre si vous ne l'utilisez pas.
    InformationsquelleAutor
  7. 11

    Active Modèles, aka "Banana split", sont un outil très pratique qui permettent de construire un match contre plusieurs modèles d'expressions régulières. C'est un peu comme AWK, mais sans la haute performance de DFA's parce que les habitudes sont appariés en séquence jusqu'à ce que l'on y réussit.

    #light
open System
open System.Text.RegularExpressions

let (|Test|_|) pat s =
    if (new Regex(pat)).IsMatch(s)
    then Some()
    else None

let (|Match|_|) pat s =
    let opt = RegexOptions.None
    let re = new Regex(pat,opt)
    let m = re.Match(s)
    if m.Success
    then Some(m.Groups)
    else None

    Quelques exemples d'utilisation:

    let HasIndefiniteArticle = function
        | Test "(?: |^)(a|an)(?: |$)" _ -> true
        | _ -> false

type Ast =
    | IntVal of string * int
    | StringVal of string * string
    | LineNo of int
    | Goto of int

let Parse = function
    | Match "^LET\s+([A-Z])\s*=\s*(\d+)$" g ->
        IntVal( g.[1].Value, Int32.Parse(g.[2].Value) )
    | Match "^LET\s+([A-Z]$)\s*=\s*(.*)$" g ->
        StringVal( g.[1].Value, g.[2].Value )
    | Match "^(\d+)\s*:$" g ->
        LineNo( Int32.Parse(g.[1].Value) )
    | Match "^GOTO \s*(\d+)$" g ->
        Goto( Int32.Parse(g.[1].Value) )
    | s -> failwithf "Unexpected statement: %s" s
    InformationsquelleAutor
  8. 8

    Peut-être monade

    type maybeBuilder() =
    member this.Bind(v, f) =
        match v with
        | None -> None
        | Some(x) -> f x
    member this.Delay(f) = f()
    member this.Return(v) = Some v

let maybe = maybeBuilder()

    Voici une brève introduction à la les monades pour les non-initiés.

    InformationsquelleAutor
  9. 8

    Option-coalescence des opérateurs

    Je voulais une version de la defaultArg fonction qui a une syntaxe proche du C# null-coalescence de l'opérateur, ??. Cela me permet d'obtenir la valeur de l'Option, tout en fournissant une valeur par défaut, à l'aide d'un très concis de la syntaxe.

    ///Option-coalescing operator - this is like the C# ?? operator, but works with 
///the Option type.
///Warning: Unlike the C# ?? operator, the second parameter will always be 
///evaluated.
///Example: let foo = someOption |? default
let inline (|?) value defaultValue =
    defaultArg value defaultValue

///Option-coalescing operator with delayed evaluation. The other version of 
///this operator always evaluates the default value expression. If you only 
///want to create the default value when needed, use this operator and pass
///in a function that creates the default.
///Example: let foo = someOption |?! (fun () -> new Default())
let inline (|?!) value f =
    match value with Some x -> x | None -> f()
    • Neat - une autre option pour le report de la version d'évaluation est d'utiliser Lazy<'a> pour le deuxième argument, au lieu de unit -> 'a, puis l'exemple ressemblerait someOption |?! lazy(new Default())
    • bon point. En fait, j'aime que mieux.
    InformationsquelleAutor
  10. 8

    'Unitize' une fonction qui ne gère pas les unités
    À l'aide de la FloatWithMeasure fonction http://msdn.microsoft.com/en-us/library/ee806527(SV.100).aspx.

    let unitize (f:float -> float) (v:float<'u>) =
  LanguagePrimitives.FloatWithMeasure<'u> (f (float v))

    Exemple: 

    [<Measure>] type m
[<Measure>] type kg

let unitize (f:float -> float) (v:float<'u>) =
  LanguagePrimitives.FloatWithMeasure<'u> (f (float v))

//this function doesn't take units
let badinc a = a + 1.

//this one does!
let goodinc v = unitize badinc v

goodinc 3.<m>
goodinc 3.<kg>

    ANCIENNE version: 

    let unitize (f:float -> float) (v:float<'u>) =
  let unit = box 1. :?> float<'u>
  unit * (f (v/unit))

    Bravo à kvb

    InformationsquelleAutor
  11. 7

    Échelle/Ratio de la fonction de générateur de

    De nouveau, trivial, mais à portée de main.

    //returns a function which will convert from a1-a2 range to b1-b2 range
let scale (a1:float<'u>, a2:float<'u>) (b1:float<'v>,b2:float<'v>) = 
    let m = (b2 - b1)/(a2 - a1) //gradient of line (evaluated once only..)
    (fun a -> b1 + m * (a - a1))

    Exemple:

    [<Measure>] type m
[<Measure>] type px

let screenSize = (0.<px>, 300.<px>)
let displayRange = (100.<m>, 200.<m>)
let scaleToScreen = scale displayRange screenSize

scaleToScreen 120.<m> //-> 60.<px>
    InformationsquelleAutor
  12. 6

    De transposition d'une liste (vu sur Jomo Fisher blog)

    ///Given list of 'rows', returns list of 'columns' 
let rec transpose lst =
    match lst with
    | (_::_)::_ -> List.map List.head lst :: transpose (List.map List.tail lst)
    | _         -> []

transpose [[1;2;3];[4;5;6];[7;8;9]] //returns [[1;4;7];[2;5;8];[3;6;9]]

    Et ici est une queue-une version récursive qui (à partir de mes croquis de profilage) est légèrement plus lent, mais a l'avantage de ne pas jeter un débordement de la pile lorsque l'intérieur des listes de plus de 10000 éléments (sur ma machine):

    let transposeTR lst =
  let rec inner acc lst = 
    match lst with
    | (_::_)::_ -> inner (List.map List.head lst :: acc) (List.map List.tail lst)
    | _         -> List.rev acc
  inner [] lst

    Si j'étais intelligent, je vais l'essayer et de paralléliser avec async...

    InformationsquelleAutor
  13. 6

    F# Map <-> C# Dictionnaire

    (Je sais, je sais, Système.Les Collections.Génériques.Le dictionnaire n'est pas vraiment un "C#" dictionary)

    C# F#

    (dic :> seq<_>)                        //cast to seq of KeyValuePair
    |> Seq.map (|KeyValue|)            //convert KeyValuePairs to tuples
    |> Map.ofSeq                       //convert to Map

    (À partir de Brian, ici, avec l'amélioration proposée par Mauricio en commentaire ci-dessous. (|KeyValue|) est une configuration active pour la mise en correspondance KeyValuePair - de FSharp.De base équivalent à (fun kvp -> kvp.Key, kvp.Value))

    Alternative intéressante

    D'obtenir toutes les lois immuables de la bonté, mais avec le O(1) recherche de la vitesse de Dictionnaire, vous pouvez utiliser le dict opérateur, qui retourne un immuable IDictionary (voir cette question).

    Actuellement, je ne peux pas voir un moyen de convertir directement un Dictionnaire à l'aide de cette méthode, autre que

    (dic :> seq<_>)                        //cast to seq of KeyValuePair
    |> (fun kvp -> kvp.Key, kvp.Value) //convert KeyValuePairs to tuples
    |> dict                            //convert to immutable IDictionary

    F# C#

    let dic = Dictionary()
map |> Map.iter (fun k t -> dic.Add(k, t))
dic

    Ce qui est étrange ici, c'est que FSI fera rapport au type (par exemple): 

    val it : Dictionary<string,int> = dict [("a",1);("b",2)]

    mais si vous nourrissez dict [("a",1);("b",2)] retour dans, le FSI rapports 

    IDictionary<string,int> = seq[[a,1] {Key = "a"; Value = 1; } ...
    • Je pense que vous êtes absent Seq.map lors de la conversion de KeyValues de tuples. Aussi, vous pouvez utiliser (|KeyValue|) au lieu de fun kvp -> kvp.Key,kvp.Value
    • bien repéré, et la tour de nice avec (|KeyValue|) - c'est près de la valeur de son propre extrait de!
    InformationsquelleAutor
  14. 5

    Arbre-trier /Aplatir un arbre dans une liste

    J'ai le texte suivant arbre binaire:

                 ___ 77 _
            /        \
   ______ 47 __       99
  /            \
21 _          54
    \        /  \
      43    53  74
     /
    39
   /
  32

    Qui est représenté comme suit:

    type 'a tree =
    | Node of 'a tree * 'a * 'a tree
    | Nil

let myTree =
    Node
      (Node
         (Node (Nil,21,Node (Node (Node (Nil,32,Nil),39,Nil),43,Nil)),47,
          Node (Node (Nil,53,Nil),54,Node (Nil,74,Nil))),77,Node (Nil,99,Nil))

    Une méthode simple pour aplatir l'arbre est:

    let rec flatten = function
    | Nil -> []
    | Node(l, a, r) -> flatten l @ a::flatten r

    Ce n'est pas la queue-récursive, et je crois que le @ opérateur entraîne O(n log n) ou O(n^2) avec déséquilibrée des arbres binaires. Avec un peu de peaufinage, je suis venu avec cette queue-récursive O(n) version:

    let flatten2 t =
    let rec loop acc c = function
        | Nil -> c acc
        | Node(l, a, r) ->
            loop acc (fun acc' -> loop (a::acc') c l) r
    loop [] (fun x -> x) t

    Voici la sortie dans fsi:

    > flatten2 myTree;;
val it : int list = [21; 32; 39; 43; 47; 53; 54; 74; 77; 99]
    • Aïe, mon cerveau...
    • Je ne sais pas si de tels exemples flatten2 sont un argument pour ou contre la poursuite de passage de style 😉
    • Pensez à la queue-une version récursive que le stockage des données dans une fermeture plutôt que sur la pile. Si vous regardez "(fun acc' -> boucle (a::acc') c l)" seuls les acc' est passé à la fonction, donc F# a une certaine manière de sauver un, c, l pour l'avenir, lorsque la fonction est évaluée.
    • Vous trouverez peut-être plus facile à écrire un pli sur votre arbre à l'aide de continuation passing style ou l'accumulation d'une pile ou d'un parent nœuds pour les récurrences de manière explicite. Ensuite, écrivez flatten en termes de fois que fold cons [] xs.
    • Je préfère le régime de la version (apply append lst1 lst2 lst3). Pas récursive si.
    InformationsquelleAutor
  15. 5

    LINQ-to-XML aides

    namespace System.Xml.Linq

//hide warning about op_Explicit
#nowarn "77"

[<AutoOpen>]
module XmlUtils =

    ///Converts a string to an XName.
    let xn = XName.op_Implicit
    ///Converts a string to an XNamespace.
    let xmlns = XNamespace.op_Implicit

    ///Gets the string value of any XObject subclass that has a Value property.
    let inline xstr (x : ^a when ^a :> XObject) =
        (^a : (member get_Value : unit -> string) x)

    ///Gets a strongly-typed value from any XObject subclass, provided that
    ///an explicit conversion to the output type has been defined.
    ///(Many explicit conversions are defined on XElement and XAttribute)
    ///Example: let value:int = xval foo
    let inline xval (x : ^a when ^a :> XObject) : ^b = 
        ((^a or ^b) : (static member op_Explicit : ^a -> ^b) x) 

    ///Dynamic lookup operator for getting an attribute value from an XElement.
    ///Returns a string option, set to None if the attribute was not present.
    ///Example: let value = foo?href
    ///Example with default: let value = defaultArg foo?Name "<Unknown>"
    let (?) (el:XElement) (name:string) =
        match el.Attribute(xn name) with
        | null -> None
        | att  -> Some(att.Value)

    ///Dynamic operator for setting an attribute on an XElement.
    ///Example: foo?href <- "http://www.foo.com/"
    let (?<-) (el:XElement) (name:string) (value:obj) =
        el.SetAttributeValue(xn name, value)
    • merci pour ces. J'ai déjà vu Tomas jeter l' ?-type d'opérateurs, mais ce que je ne comprends pas, c'est comment le nom-que-code de magie est converti en nom en tant que chaîne de caractères (comment venir vous n'avez pas à faire foo?"href"?). Et par quelle magie le ?<- "venez à part" dans le milieu? Mon ignorance est mis à nu devant tous
    • C'est un compilateur truc. Le compilateur F# transforme la définition de la ? opérateur dans une méthode de classe statique appelé op_Dynamic qui prend un paramètre de chaîne. Il se tourne ensuite utilise de la ? opérateur dans les appels à cette méthode, avec la partie après le point d'interrogation comme le paramètre de la chaîne. Donc, à l'exécution, il est tout à typage statique et non dynamique à tous, il fournit simplement quelques belles concis de la syntaxe que vous obtenez pour définir le comportement de. Même principe avec le ?<- de l'opérateur.
    InformationsquelleAutor
  16. 4

    Somme pondérée des tableaux

    Calcul pondéré [n-array] somme de [k-tableau de n-tableaux] de numéros, basé sur un [k-array] de poids

    (Copié à partir de cette question, et kvb's réponse)

    Compte tenu de ces tableaux

    let weights = [|0.6;0.3;0.1|]

let arrs = [| [|0.0453;0.065345;0.07566;1.562;356.6|] ; 
           [|0.0873;0.075565;0.07666;1.562222;3.66|] ; 
           [|0.06753;0.075675;0.04566;1.452;3.4556|] |]

    Nous voulons une somme pondérée (par colonne), étant donné que les deux dimensions des tableaux peut être variable.

    Array.map2 (fun w -> Array.map ((*) w)) weights arrs 
|> Array.reduce (Array.map2 (+))

    Première ligne: application Partielle de la première pile.map2 fonction de poids produit une nouvelle fonction (Tableau).carte ((*) le poids) qui est appliqué (pour chaque poids) de chaque tableau en arr.

    Deuxième ligne: Tableau.réduire, c'est comme pli, sauf qu'il commence à la deuxième valeur, et utilise la première initiale de l'état. Dans ce cas, chaque valeur est une "ligne" de notre tableau de tableaux. Ainsi, à l'application d'un Tableau.map2 (+) sur les deux premières lignes signifie que nous somme les deux premiers tableaux, qui nous laisse avec un nouveau tableau, que nous avons ensuite (Tableau.réduire) la somme de nouveau sur la prochaine (dans ce dernier cas) tableau.

    Résultat:

    [|0.060123; 0.069444; 0.07296; 1.5510666; 215.40356|]
    • Ce souffle m'éloigner parce que je n'aurais jamais cru cela possible de map2 deux disparates listes.
    InformationsquelleAutor
  17. 4

    Tests de Performance

    (Trouvé ici et mis à jour pour la dernière version de F#)

    open System
open System.Diagnostics 
module PerformanceTesting =
    let Time func =
        let stopwatch = new Stopwatch()
        stopwatch.Start()
        func()
        stopwatch.Stop()
        stopwatch.Elapsed.TotalMilliseconds

    let GetAverageTime timesToRun func = 
        Seq.initInfinite (fun _ -> (Time func))
        |> Seq.take timesToRun
        |> Seq.average

    let TimeOperation timesToRun =
        GC.Collect()
        GetAverageTime timesToRun

    let TimeOperations funcsWithName =
        let randomizer = new Random(int DateTime.Now.Ticks)
        funcsWithName
        |> Seq.sortBy (fun _ -> randomizer.Next())
        |> Seq.map (fun (name, func) -> name, (TimeOperation 100000 func))

    let TimeOperationsAFewTimes funcsWithName =
        Seq.initInfinite (fun _ -> (TimeOperations funcsWithName))
        |> Seq.take 50
        |> Seq.concat
        |> Seq.groupBy fst
        |> Seq.map (fun (name, individualResults) -> name, (individualResults |> Seq.map snd |> Seq.average))
    • FWIW, stopwatch.Elapsed.TotalSeconds est plus précis.
    • comment? pourquoi?
    • IIRC, son sujet de 100x plus précis.
    InformationsquelleAutor
  18. 3

    OK, cela n'a rien à voir avec les extraits de code, mais j'oublie ceci:

    Si vous êtes dans la fenêtre interactive, vous frappez F7 pour revenir à la fenêtre de code (sans désélectionner le code qui vous a juste couru...)

    Allant de la fenêtre de code F# fenêtre (et aussi pour ouvrir le F# fenêtre) Ctrl Alt F

    (sauf CodeRush a volé vos fixations...)

    • FWIW, vous pouvez modifier la combinaison de touches Ctrl+Alt+F CodeRush de liaison de sorte qu'il ne fonctionne que dans les langues qui sont pris en charge par le DXCore (c'est à dire pas F#). pour ce faire: repérer le "DevExpress\CodeRush\" Options de menu ... Choisissez IDE\Raccourcis sur la gauche ... Recherchez la Navigation\Ctrl+Alt+F raccourci. Mettre en surbrillance, puis cochez la case "Langue\Active de la Langue prise en charge" élément de contexte sur la droite. Cliquez sur ok et ce raccourci devrait commencer à travailler comme vous le souhaitez.
    InformationsquelleAutor
  19. 3

    DataSetExtensions F# DataReaders

    System.Data.DataSetExtensions.dll ajoute la capacité de traiter un DataTable comme un IEnumerable<DataRow> ainsi que unboxing les valeurs des cellules individuelles d'une manière qui s'poignées DBNull par Système de soutien.Nullable. Par exemple, en C#, nous pouvons obtenir la valeur d'un entier de la colonne qui contient les valeurs null, et de préciser que DBNull devrait être par défaut à zéro avec un très concis syntaxe:

    var total = myDataTable.AsEnumerable()
                       .Select(row => row.Field<int?>("MyColumn") ?? 0)
                       .Sum();

    Il y a deux domaines où DataSetExtensions manquent cependant. Tout d'abord, il ne prend pas en charge IDataReader et, deuxièmement, elle ne prend pas en charge le F# option type. Le code suivant fait à la fois - il permet à un IDataReader d'être traité comme un seq<IDataRecord>, et il peut unbox valeurs à partir d'un lecteur ou d'un ensemble de données, avec le soutien de F# options ou d'un Système.Nullable. Combinée avec l'option-coalescence de l'opérateur dans une autre réponse, ce qui permet le code comme suit lorsque l'on travaille avec un DataReader:

    let total =
    myReader.AsSeq
    |> Seq.map (fun row -> row.Field<int option>("MyColumn") |? 0)
    |> Seq.sum

    Peut-être plus idiomatiques F# façon d'ignorer la base de données les valeurs null serait...

    let total =
    myReader.AsSeq
    |> Seq.choose (fun row -> row.Field<int option>("MyColumn"))
    |> Seq.sum

    En outre, l'extension des méthodes définies ci-dessous sont utilisables à partir de deux F# et en C#/VB.

    open System
open System.Data
open System.Reflection
open System.Runtime.CompilerServices
open Microsoft.FSharp.Collections
///Ported from System.Data.DatasetExtensions.dll to add support for the Option type.
[<AbstractClass; Sealed>]
type private UnboxT<'a> private () =
//This class generates a converter function based on the desired output type,
//and then re-uses the converter function forever. Because the class itself is generic,
//different output types get different cached converter functions.
static let referenceField (value:obj) =
if value = null || DBNull.Value.Equals(value) then
Unchecked.defaultof<'a>
else
unbox value
static let valueField (value:obj) =
if value = null || DBNull.Value.Equals(value) then
raise <| InvalidCastException("Null cannot be converted to " + typeof<'a>.Name)
else
unbox value
static let makeConverter (target:Type) methodName =
Delegate.CreateDelegate(typeof<Converter<obj,'a>>,
typeof<UnboxT<'a>>
.GetMethod(methodName, BindingFlags.NonPublic ||| BindingFlags.Static)
.MakeGenericMethod([| target.GetGenericArguments().[0] |]))
|> unbox<Converter<obj,'a>>
|> FSharpFunc.FromConverter
static let unboxFn =
let theType = typeof<'a>
if theType.IsGenericType && not theType.IsGenericTypeDefinition then
let genericType = theType.GetGenericTypeDefinition()
if typedefof<Nullable<_>> = genericType then
makeConverter theType "NullableField"
elif typedefof<option<_>> = genericType then
makeConverter theType "OptionField"
else
invalidOp "The only generic types supported are Option<T> and Nullable<T>."
elif theType.IsValueType then
valueField
else
referenceField
static member private NullableField<'b when 'b : struct and 'b :> ValueType and 'b:(new:unit -> 'b)> (value:obj) =
if value = null || DBNull.Value.Equals(value) then
Nullable<_>()
else
Nullable<_>(unbox<'b> value)
static member private OptionField<'b> (value:obj) =
if value = null || DBNull.Value.Equals(value) then
None
else
Some(unbox<'b> value)
static member inline Unbox =
unboxFn
///F# data-related extension methods.
[<AutoOpen>]
module FsDataEx =
type System.Data.IDataReader with
///Exposes a reader's current result set as seq<IDataRecord>.
///Reader is closed when sequence is fully enumerated.
member this.AsSeq =
seq { use reader = this
while reader.Read() do yield reader :> IDataRecord }
///Exposes all result sets in a reader as seq<seq<IDataRecord>>.
///Reader is closed when sequence is fully enumerated.
member this.AsMultiSeq =
let rowSeq (reader:IDataReader)  =
seq { while reader.Read() do yield reader :> IDataRecord }
seq {
use reader = this
yield rowSeq reader
while reader.NextResult() do
yield rowSeq reader
}
///Populates a new DataSet with the contents of the reader. Closes the reader after completion.
member this.ToDataSet () =
use reader = this
let dataSet = new DataSet(RemotingFormat=SerializationFormat.Binary, EnforceConstraints=false)
dataSet.Load(reader, LoadOption.OverwriteChanges, [| "" |])
dataSet
type System.Data.IDataRecord with
///Gets a value from the record by name. 
///DBNull and null are returned as the default value for the type.
///Supports both nullable and option types.
member this.Field<'a> (fieldName:string) =
this.[fieldName] |> UnboxT<'a>.Unbox
///Gets a value from the record by column index. 
///DBNull and null are returned as the default value for the type.
///Supports both nullable and option types.
member this.Field<'a> (ordinal:int) =
this.GetValue(ordinal) |> UnboxT<'a>.Unbox
type System.Data.DataRow with
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (columnName:string) =
this.[columnName] |> UnboxT<'a>.Unbox
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (columnIndex:int) =
this.[columnIndex] |> UnboxT<'a>.Unbox
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (column:DataColumn) =
this.[column] |> UnboxT<'a>.Unbox
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (columnName:string, version:DataRowVersion) =
this.[columnName, version] |> UnboxT<'a>.Unbox
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (columnIndex:int, version:DataRowVersion) =
this.[columnIndex, version] |> UnboxT<'a>.Unbox
///Identical to the Field method from DatasetExtensions, but supports the F# Option type.
member this.Field2<'a> (column:DataColumn, version:DataRowVersion) =
this.[column, version] |> UnboxT<'a>.Unbox
///C# data-related extension methods.
[<Extension; AbstractClass; Sealed>]
type CsDataEx private () =
///Populates a new DataSet with the contents of the reader. Closes the reader after completion.
[<Extension>]    
static member ToDataSet(this:IDataReader) =
this.ToDataSet()
///Exposes a reader's current result set as IEnumerable{IDataRecord}.
///Reader is closed when sequence is fully enumerated.
[<Extension>]
static member AsEnumerable(this:IDataReader) =
this.AsSeq
///Exposes all result sets in a reader as IEnumerable{IEnumerable{IDataRecord}}.
///Reader is closed when sequence is fully enumerated.
[<Extension>]
static member AsMultipleEnumerable(this:IDataReader) =
this.AsMultiSeq
///Gets a value from the record by name. 
///DBNull and null are returned as the default value for the type.
///Supports both nullable and option types.
[<Extension>]
static member Field<'T> (this:IDataRecord, fieldName:string) =
this.Field<'T>(fieldName)
///Gets a value from the record by column index. 
///DBNull and null are returned as the default value for the type.
///Supports both nullable and option types.
[<Extension>]
static member Field<'T> (this:IDataRecord, ordinal:int) =
this.Field<'T>(ordinal)
    InformationsquelleAutor
  20. 2

    La manipulation des arguments dans une application en ligne de commande:

    //We assume that the actual meat is already defined in function 
//   DoStuff (string -> string -> string -> unit)
let defaultOutOption = "N"
let defaultUsageOption = "Y"
let usage =  
"Scans a folder for and outputs results.\n" +
"Usage:\n\t MyApplication.exe FolderPath [IncludeSubfolders (Y/N) : default=" + 
defaultUsageOption + "] [OutputToFile (Y/N): default=" + defaultOutOption + "]"
let HandlArgs arr = 
match arr with
| [|d;u;o|] -> DoStuff d u o
| [|d;u|] -> DoStuff d u defaultOutOption 
| [|d|] -> DoStuff d defaultUsageOption defaultOutOption 
| _ ->  
printf "%s" usage
Console.ReadLine() |> ignore
[<EntryPoint>]
let main (args : string array) = 
args |> HandlArgs
0

    (J'avais un vague souvenir de cette technique, inspirée par Robert Pickering, mais ne peut pas trouver une référence maintenant)

    InformationsquelleAutor
  21. 2

    Pratique du fonctionnement de la mémoire cache qui garde jusqu'à max (key,reader(key)) dans un dictionnaire et d'utiliser un SortedList pour suivre le MRU clés

    let Cache (reader: 'key -> 'value) max = 
let cache = new Dictionary<'key,LinkedListNode<'key * 'value>>()
let keys = new LinkedList<'key * 'value>()
fun (key : 'key) -> ( 
let found, value = cache.TryGetValue key
match found with
|true ->
keys.Remove value
keys.AddFirst value |> ignore
(snd value.Value)
|false -> 
let newValue = key,reader key
let node = keys.AddFirst newValue
cache.[key] <- node
if (keys.Count > max) then
let lastNode = keys.Last
cache.Remove (fst lastNode.Value) |> ignore
keys.RemoveLast() |> ignore
(snd newValue))
    • Désolé, je voulais dire MRU (les Plus Récemment Utilisés). Imaginez lecteur comme un lent fonction de recherche que l'accès à une base de données à distance ou d'un service web ou même un très lourd calcul.
    • Oui, je peux voir l'utilisation d'un cache, pas seulement pour "l'élagage" il. Je me demande si je ne devrais pas mettre un extrait ici pour memoization (si je peux en trouver un!)
    InformationsquelleAutor
  22. 2

    La Création De XElements

    Rien d'étonnant, mais je continue de se faire prendre par la conversion implicite de XNames:

    #r "System.Xml.Linq.dll"
open System.Xml.Linq
//No! ("type string not compatible with XName")
//let el = new XElement("MyElement", "text") 
//better
let xn s = XName.op_Implicit s
let el = new XElement(xn "MyElement", "text")
//or even
let xEl s o = new XElement(xn s, o)
let el = xEl "MyElement" "text"
    • Que la conversion est une partie de .Net, il a de l'implicite cast(String, XElement) surchargé. Donc, de tout .Net de la langue qui prend en charge la conversion de surcharger la prend en charge. Fonctionnalité intéressante de toute façon.
    • J'ai peur qu'elle est un peu plus compliqué que cela: codebetter.com/blogs/matthew.podwysocki/archive/2009/06/11/...
    • Ah, explique la fonctionnalité. Mais lors de l'analyse, j'ai été incapable de trouver la raison pour laquelle F# ne prend pas en charge l'opérateur de coulée.
    InformationsquelleAutor
  23. 2

    Par paires et des paires de

    J'ai toujours s'attendre à Seq.paires de me donner [(1,2);(3;4)] et pas [(1,2);(2,3);(3,4)]. Étant donné que ni existe pas dans la Liste, et que je devais à la fois, voici le code de référence pour l'avenir. Je pense elles sont la queue récursive.

    //converts to 'windowed tuples' ([1;2;3;4;5] -> [(1,2);(2,3);(3,4);(4,5)])
let pairwise lst = 
let rec loop prev rem acc = 
match rem with
| hd::tl -> loop hd tl ((prev,hd)::acc)
| _ -> List.rev acc
loop (List.head lst) (List.tail lst) []
//converts to 'paged tuples' ([1;2;3;4;5;6] -> [(1,2);(3,4);(5,6)])    
let pairs lst = 
let rec loop rem acc = 
match rem with
| l::r::tl -> loop tl ((l,r)::acc)
| l::[] -> failwith "odd-numbered list" 
| _ -> List.rev acc
loop lst []
    InformationsquelleAutor
  24. 1

    Naïf CSV reader (c'est à dire, de ne pas gérer quoi que ce soit de méchant)

    (À l'aide de filereadlines et de la Liste.la transposition d'autres réponses ici)

    ///Given a file path, returns a List of row lists
let ReadCSV = 
filereadlines
>> Array.map ( fun line -> line.Split([|',';';'|]) |> List.ofArray )
>> Array.toList
///takes list of col ids and list of rows, 
///  returns array of columns (in requested order)
let GetColumns cols rows = 
//Create filter
let pick cols (row:list<'a>) = List.map (fun i -> row.[i]) cols
rows 
|> transpose //change list of rows to list of columns
|> pick cols      //pick out the columns we want
|> Array.ofList  //an array output is easier to index for user

    Exemple

    "C:\MySampleCSV"
|> ReadCSV
|> List.tail //skip header line
|> GetColumns [0;3;1]  //reorder columns as well, if needs be.
    InformationsquelleAutor
  25. 1

    Plage de dates

    simple mais utile liste de dates entre fromDate et toDate

    let getDateRange  fromDate toDate  =
let rec dates (fromDate:System.DateTime) (toDate:System.DateTime) = 
seq {
if fromDate <= toDate then 
yield fromDate
yield! dates (fromDate.AddDays(1.0)) toDate
}
dates fromDate toDate
|> List.ofSeq
    InformationsquelleAutor
  26. 1

    activer /désactiver le code sql

    Plus trivial que la plupart sur cette liste, mais pratique néanmoins:

    Je suis toujours en prenant sql dans et hors de code pour le déplacer vers un sql environnement au cours du développement. Exemple:

    let sql = "select a,b,c "
+ "from table "
+ "where a = 1"

    doit être "dépouillé" pour:

    select a,b,c
from table
where a = 1

    en gardant la mise en forme. C'est une douleur à dépouiller le symbole de code de l'éditeur sql, puis les mettre à nouveau la main quand j'en ai le sql travaillé. Ces deux fonctions basculer le sql en arrière à partir de code dépouillé:

    //reads the file with the code quoted sql, strips code symbols, dumps to FSI
let stripForSql fileName = 
File.ReadAllText(fileName)
|> (fun s -> Regex.Replace(s, "\+(\s*)\"", "")) 
|> (fun s -> s.Replace("\"", ""))
|> (fun s -> Regex.Replace(s, ";$", "")) //end of line semicolons
|> (fun s -> Regex.Replace(s, "//.+", "")) //get rid of any comments
|> (fun s -> printfn "%s" s)

    puis lorsque vous êtes prêt à mettre dans votre code source du fichier:

    let prepFromSql fileName = 
File.ReadAllText(fileName)
|> (fun s -> Regex.Replace(s, @"\r\n", " \"\r\n+\"")) //matches newline 
|> (fun s -> Regex.Replace(s, @"\A", " \"")) 
|> (fun s -> Regex.Replace(s, @"\z", " \"")) 
|> (fun s -> printfn "%s" s)

    J'avais amour pour se débarrasser du fichier d'entrée, mais ne peut même pas commencer à analyser la façon de faire que cela se produise. quelqu'un?

    edit:

    J'ai compris comment faire pour supprimer l'exigence d'un fichier de ces fonctions par l'ajout d'un windows forms boîte de dialogue d'entrée/sortie. Trop de code à montrer, mais pour ceux qui voudraient faire une telle chose, c'est comment je l'ai résolu.

    • Je n'ai pas un compilateur à la main pour votre dernière question, mais je voudrais les utiliser pour faire de votre tuyauterie plus joli: let replace f r (s:string) = s.Replace(f,r) et let regreplace p r s = Regex.Replace(s, p, r) (non testé)
    InformationsquelleAutor
  27. 1

    Le Triangle de Pascal (hey, quelqu'un pourrait trouver utile)

    Si nous voulons créer quelque chose comme ceci:

           1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

    Assez facile:

    let rec next = function
| [] -> []
| x::y::xs -> (x + y)::next (y::xs)
| x::xs -> x::next xs
let pascal n =
seq { 1 .. n }
|> List.scan (fun acc _ -> next (0::acc) ) [1]

    La next fonction renvoie une nouvelle liste dans laquelle chaque élément[i] = item[i] + élément[i + 1].

    Voici la sortie dans fsi:

    > pascal 10 |> Seq.iter (printfn "%A");;
[1]
[1; 1]
[1; 2; 1]
[1; 3; 3; 1]
[1; 4; 6; 4; 1]
[1; 5; 10; 10; 5; 1]
[1; 6; 15; 20; 15; 6; 1]
[1; 7; 21; 35; 35; 21; 7; 1]
[1; 8; 28; 56; 70; 56; 28; 8; 1]
[1; 9; 36; 84; 126; 126; 84; 36; 9; 1]
[1; 10; 45; 120; 210; 252; 210; 120; 45; 10; 1]

    Pour les plus aventureux, voici une queue-une version récursive:

    let rec next2 cont = function
| [] -> cont []
| x::y::xs -> next2 (fun l -> cont <| (x + y)::l ) <| y::xs
| x::xs -> next2 (fun l -> cont <| x::l ) <| xs
let pascal2 n =
set { 1 .. n }
|> Seq.scan (fun acc _ -> next2 id <| 0::acc)) [1]
    InformationsquelleAutor
  28. 0

    Aplatir une Liste

    si vous avez quelque chose comme ceci:

    let listList = [[1;2;3;];[4;5;6]]

    et veulent "aplatir" il vers le bas pour un seul de la liste de sorte que le résultat ressemble à ceci:

    [1;2;3;4;5;6]

    il peut être fait ainsi:

    let flatten (l: 'a list list) =
seq {
yield List.head (List.head l) 
for a in l do yield! (Seq.skip 1 a) 
} 
|> List.ofSeq
    • Terriblement désolé, mais je pense que ce qui existe déjà: c'est List.concat. (Ce qui m'arrive tout le temps de codage d'une fonction découvrant alors qu'il est déjà là!). Il serait intéressant de voir si il y a une fonction qui fait ce "de manière récursive' (c'est à dire pour [[[1;2;3;];[4;5;6]];[[1;2;3;];[4;5;6]]])
    • doh! L'homme--et j'ai vraiment cherché un moyen de le faire b4 rouler mes propres.
    • List.concat est certainement le chemin à faire, avant je l'ai trouvé j'ai été en utilisant List.collect id
    InformationsquelleAutor
  29. 0

    Interprétations de la liste pour float

    Ce [23.0 .. 1.0 .. 40.0] a été marquée comme obsolète quelques versions soutenu.

    Mais apparemment, cela fonctionne:

    let dl = 9.5 / 11.
let min = 21.5 + dl
let max = 40.5 - dl
let a = [ for z in min .. dl .. max -> z ]
let b = a.Length

    (BTW, il y a une virgule flottante gotcha là. Découvert à fssnip - l'autre endroit pour F# extraits)

    InformationsquelleAutor
  30. -2

    Parallèle de la carte

    let pmap f s =
seq { for a in s -> async { return f s } }
|> Async.Parallel
|> Async.Run
    • Asynchrone des flux de travail impliquent des frais généraux et des mauvais équilibrage de la charge pour les CPU-intensive de travail, donc c'est une mauvaise solution pour le parallélisme. Beaucoup mieux d'utiliser le construit en Array.Parallel.map maintenant.
    InformationsquelleAutor
  31. -2

    Établissant un record à null

    type Foo = { x : int }
let inline retype (x:'a) : 'b = (# "" x : 'b #)
let f : Foo = retype null
    • Pas besoin d'obtenir de fantaisie: let f : Foo = Unchecked.defaultof<_>
    InformationsquelleAutor