Oz-Projects
Merci de vous enregistrer ou de vous connecter.

Oz-Projects

Oz-Projects, les applications qu'il faut Ozer !
 
AccueilFAQRechercherMembresGroupesS'enregistrerConnexion

Partagez | 
 

 [Tutoriel] Base du langage F#

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:40

Code:
// Cet exemple est destiné à vous montrer les différents éléments du langage F#. 
//
// *******************************************************************************************************
//  Pour exécuter le code dans F# Interactive, mettez en surbrillance une portion du code, puis appuyez sur Alt+Entrée ou cliquez avec le bouton droit,
//  puis sélectionnez Exécuter en mode interactif.  Pour ouvrir la fenêtre F# Interactive, accédez au menu Affichage.
// *******************************************************************************************************
//
// Pour en savoir plus sur F#, consultez :
//    http://fsharp.net
//
// Pour consulter d'autres modèles d'utilisation du langage F#, cliquez sur Modèles en ligne dans Visual Studio,
//    'Nouveau projet' --> 'Modèles en ligne'
//
// Pour afficher des rubriques F# spécifiques, consultez :
//    http://go.microsoft.com/fwlink/?LinkID=234174 (Portail de développement F#)
//    http://go.microsoft.com/fwlink/?LinkID=124614 (Code Gallery)
//    http://go.microsoft.com/fwlink/?LinkId=235173 (Programmation math/stats)
//    http://go.microsoft.com/fwlink/?LinkId=235176 (Graphiques)

// Sommaire :
//    - Les entiers et les fonctions de base
//    - Les booléens
//    - Les chaînes
//    - Les tuples
//    - Les listes et leur traitement
//    - Les classes
//    - Les classes génériques
//    - L'implémentation des interfaces
//    - Les tableaux
//    - Les séquences
//    - Les fonctions récursives
//    - Les types d'enregistrements
//    - Les types union
//    - Les types d'options           
//    - Les critères spéciaux       
//    - Les unités de mesure       
//    - La programmation parallèle de tableaux
//    - L'utilisation des événements
//    - L'accès aux bases de données à l'aide des fournisseurs de types
//    - L'accès aux données OData à l'aide des fournisseurs de type
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:41

Code:
// ---------------------------------------------------------------
//        Les entiers et les fonctions de base
// ---------------------------------------------------------------

module Integers =
    let sampleInteger = 176

    /// Faites un peu d'arithmétique avec le premier entier
    let sampleInteger2 = (sampleInteger/4 + 5 - 7) * 4

    /// Liste des nombres entre 0 et 99
    let sampleNumbers = [ 0 .. 99 ]

    /// Liste de tous les tuples contenant tous les nombres de 0 à 99 et leurs carrés
    let sampleTableOfSquares = [ for i in 0 .. 99 -> (i, i*i) ]

    // La ligne suivante imprime une liste comprenant des tuples, en utilisant %A pour l'impression générique
    printfn "The table of squares from 0 to 99 is:\n%A" sampleTableOfSquares


module BasicFunctions =

    // Utilisez 'let' pour définir une fonction qui accepte un argument entier et renvoie un entier.
    let func1 x = x*x + 3           

    // Les parenthèses sont facultatives pour les arguments de fonction.
    let func1a (x) = x*x + 3           

    /// Appliquez la fonction, en nommant le résultat de retour de la fonction à l'aide de 'let'.
    /// Le type de variable est déduit du type de retour de la fonction.
    let result1 = func1 4573
    printfn "The result of squaring the integer 4573 and adding 3 is %d" result1

    // Si nécessaire, annotez le type des noms de paramètres à l'aide de '(argument:type)'.
    let func2 (x:int) = 2*x*x - x/5 + 3

    let result2 = func2 (7 + 4)
    printfn "The result of applying the 1st sample function to (7 + 4) is %d" result2

    let func3 x =
        if x < 100.0 then
            2.0*x*x - x/5.0 + 3.0
        else
            2.0*x*x + x/5.0 - 37.0

    let result3 = func3 (6.5 + 4.5)
    printfn "The result of applying the 2nd sample function to (6.5 + 4.5) is %f" result3

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:41

Code:
// ---------------------------------------------------------------
//        Les booléens
// ---------------------------------------------------------------

module SomeBooleanValues =

    let boolean1 = true
    let boolean2 = false

    let boolean3 = not boolean1 && (boolean2 || false)

    printfn "The expression 'not boolean1 && (boolean2 || false)' is %A" boolean3

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:41

Code:
// ---------------------------------------------------------------
//        Les chaînes
// ---------------------------------------------------------------

module StringManipulation =

    let string1 = "Hello"
    let string2  = "world"

    /// Utilisez @ pour créer un littéral de chaîne textuelle
    let string3 = @"c:\Program Files\"

    /// À l'aide d'un littéral de chaîne à guillemets triples,
    let string4 = """He said "hello world" after you did"""

    let helloWorld = string1 + " " + string2 // concaténez les deux chaînes en les séparant par un espace.
    printfn "%s" helloWorld

    /// Chaîne formée en prenant les 7 premiers caractères de l'une des chaînes de résultats
    let substring = helloWorld.[0..6]
    printfn "%s" substring

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:42

Code:
// ---------------------------------------------------------------
//        Les tuples (ensembles de valeurs ordonnés)
// ---------------------------------------------------------------

module Tuples =

    /// Tuple simple d'entiers
    let tuple1 = (1, 2, 3)

    /// Fonction qui inverse l'ordre de deux valeurs d'un tuple.
    /// Les InfosRapides montrent que la fonction est déduite afin d'obtenir un type générique.
    let swapElems (a, b) = (b, a)

    printfn "The result of swapping (1, 2) is %A" (swapElems (1,2))

    /// Tuple constitué d'un entier, d'une chaîne et d'un nombre à virgule flottante à double précision
    let tuple2 = (1, "fred", 3.1415)

    printfn "tuple1: %A    tuple2: %A" tuple1 tuple2
   
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:42

Code:
// ---------------------------------------------------------------
//        Les listes et leur traitement
// ---------------------------------------------------------------

module Lists =

    let list1 = [ ]            /// une liste vide

    let list2 = [ 1; 2; 3 ]    /// liste de 3 éléments

    let list3 = 42 :: list2    /// nouvelle liste préfixée de '42'

    let numberList = [ 1 .. 1000 ]  /// liste d'entiers allant de 1 à 1000

    /// Liste contenant tous les jours de l'année
    let daysList =
        [ for month in 1 .. 12 do
              for day in 1 .. System.DateTime.DaysInMonth(2012, month) do
                  yield System.DateTime(2012, month, day) ]

    /// Liste contenant les tuples correspondant aux coordonnées des cases noires d'un échiquier.
    let blackSquares =
        [ for i in 0 .. 7 do
              for j in 0 .. 7 do
                  if (i+j) % 2 = 1 then
                      yield (i, j) ]

    /// Élevez au carré les nombres compris dans numberList, en utilisant l'opérateur pipeline pour passer un argument à List.map   
    let squares =
        numberList
        |> List.map (fun x -> x*x)

    /// Calcule la somme des carrés des nombres divisibles par 3.
    let sumOfSquaresUpTo n =
        numberList
        |> List.filter (fun x -> x % 3 = 0)
        |> List.sumBy (fun x -> x * x)

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:42

Code:
// ---------------------------------------------------------------
//        Les classes
// ---------------------------------------------------------------

module DefiningClasses =

    /// Le constructeur de la classe prend deux arguments : dx et dy, tous deux de type 'float'.
    type Vector2D(dx : float, dy : float) =
        /// Longueur du vecteur, calculée lors de la création de l'objet
        let length = sqrt (dx*dx + dy*dy)

        // 'this' spécifie un nom pour l'auto-identificateur de l'objet.
        // Dans les méthodes d'instance, il doit apparaître avant le nom du membre.
        member this.DX = dx 

        member this.DY = dy

        member this.Length = length

        member this.Scale(k) = Vector2D(k * this.DX, k * this.DY)
   
    /// Instance de la classe Vector2D
    let vector1 = Vector2D(3.0, 4.0)

    /// Obtenez un nouvel objet de vecteur mis à l'échelle, sans modifier l'objet d'origine
    let vector2 = vector1.Scale(10.0)

    printfn "Length of vector1: %f      Length of vector2: %f" vector1.Length vector2.Length

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:42

Code:
// ---------------------------------------------------------------
//        Les classes génériques
// ---------------------------------------------------------------

module DefiningGenericClasses =

    type StateTracker<'T>(initialElement: 'T) = // 'T est le paramètre de type de la classe

        /// Stockez les états dans un tableau
        let mutable states = [ initialElement ]

        /// Ajouter un nouvel élément à la liste des états
        member this.UpdateState newState =
            states <- newState :: states  // utilisez l'opérateur '<-' pour muter la valeur

        /// Obtenir la totalité de la liste des états historiques
        member this.History = states

        /// Obtenir le dernier état
        member this.Current = states.Head

    /// Instance 'int' de la classe de suivi des états. Notez que le paramètre de type est déduit.
    let tracker = StateTracker 10

    // Ajouter un état
    tracker.UpdateState 17

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:43

Code:
// ---------------------------------------------------------------
//        L'implémentation des interfaces
// ---------------------------------------------------------------

/// Type qui implémente IDisposable
type ReadFile() =

    let file = new System.IO.StreamReader("readme.txt")

    member this.ReadLine() = file.ReadLine()

    // implémentation des membres IDisposable de cette classe
    interface System.IDisposable with   
        member this.Dispose() = file.Close()
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:43

Code:
// ---------------------------------------------------------------
//        Les tableaux
// ---------------------------------------------------------------

module Arrays =

    /// Tableau vide
    let array1 = [| |]

    let array2 = [| "hello"; "world"; "and"; "hello"; "world"; "again" |]

    let array3 = [| 1 .. 1000 |]

    /// Tableau contenant uniquement les mots  "hello" et "world"
    let array4 = [| for word in array2 do
                        if word.Contains("l") then
                            yield word |]

    /// Tableau initialisé par l'index et contenant les nombres pairs compris entre 0 et 2000
    let evenNumbers = Array.init 1001 (fun n -> n * 2)

    /// sous-tableau extrait à l'aide de la notation de découpage
    let evenNumbersSlice = evenNumbers.[0..500]

    for word in array4 do
        printfn "word: %s" word

    // modifiez un élément de tableau à l'aide de l'opérateur d'assignation flèche gauche
    array2.[1] <- "WORLD!"

    /// Calcule la somme des longueurs des mots commençant par 'h'
    let sumOfLengthsOfWords =
        array2
        |> Array.filter (fun x -> x.StartsWith "h")
        |> Array.sumBy (fun x -> x.Length)
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:43

Code:
// ---------------------------------------------------------------
//        Les séquences
// ---------------------------------------------------------------

module Sequences =
    // Les séquences sont évaluées sur demande et sont réévaluées à chacune de leur itération.
    // Une séquence F# est une instance de System.Collections.Generic.IEnumerable<'T>,
    // par conséquent, les fonctions Seq peuvent également être appliquées aux listes et aux tableaux.

    /// Séquence vide
    let seq1 = Seq.empty

    let seq2 = seq { yield "hello"; yield "world"; yield "and"; yield "hello"; yield "world"; yield "again" }

    let numbersSeq = seq { 1 .. 1000 }

    /// autre tableau contenant uniquement les mots "hello" et "world"
    let seq3 =
        seq { for word in seq2 do
                  if word.Contains("l") then
                      yield word }

    let evenNumbers = Seq.init 1001 (fun n -> n * 2)

    let rnd = System.Random()

    /// Séquence infinie correspondant à une balade à pied
    //  Utilisez yield! pour renvoyer chacun des éléments d'une sous-séquence, similaire à IEnumerable.SelectMany.
    let rec randomWalk x =
        seq { yield x
              yield! randomWalk (x + rnd.NextDouble() - 0.5) }

    let first100ValuesOfRandomWalk =
        randomWalk 5.0
        |> Seq.truncate 100
        |> Seq.toList

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:43

Code:
// ---------------------------------------------------------------
//        Les fonctions récursives
// ---------------------------------------------------------------

module RecursiveFunctions  =
             
    /// Calculez la factorielle d'un entier. Utilisez 'let rec' pour définir une fonction récursive.
    let rec factorial n =
        if n = 0 then 1 else n * factorial (n-1)

    /// Calcule le facteur commun le plus élevé de deux entiers.
    //  Étant donné que tous les appels récursifs sont des appels tail, le compilateur convertira la fonction en boucle,
    //  ce qui permettra d'améliorer les performances et de réduire la consommation de mémoire.
    let rec greatestCommonFactor a b =                     
        if a = 0 then b
        elif a < b then greatestCommonFactor a (b - a)         
        else greatestCommonFactor (a - b) b

    /// Calcule la somme des entiers d'une liste à l'aide de la récursivité.
    let rec sumList xs =
        match xs with
        | []    -> 0
        | y::ys -> y + sumList ys

    /// Convertissez la fonction en fonction à récursivité terminale, en utilisant une fonction d'assistance avec accumulateur de résultats.
    let rec private sumListTailRecHelper accumulator xs =
        match xs with
        | []    -> accumulator
        | y::ys -> sumListTailRecHelper (accumulator+y) ys

    let sumListTailRecursive xs = sumListTailRecHelper 0 xs

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:43

Code:
// ---------------------------------------------------------------
//        Les types d'enregistrements
// ---------------------------------------------------------------

module RecordTypes =

    // définissez un type d'enregistrement
    type ContactCard =
        { Name    : string;
          Phone    : string;
          Verified : bool }
             
    let contact1 = { Name = "Alf" ; Phone = "(206) 555-0157" ; Verified = false }

    // créez un nouvel enregistrement correspondant à une copie de contact1,
    // mais possédant des valeurs différentes dans les champs Téléphone et Vérifié
    let contact2 = { contact1 with Phone = "(206) 555-0112"; Verified = true }

    /// Convertit un objet 'ContactCard' en chaîne
    let showCard c =
        c.Name + " Phone: " + c.Phone + (if not c.Verified then " (unverified)" else "")
       
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:44

Code:
// ---------------------------------------------------------------
//        Les types union
// ---------------------------------------------------------------

module UnionTypes =

    /// Représente la couleur d'une carte à jouer
    type Suit =
        | Hearts
        | Clubs
        | Diamonds
        | Spades

    /// Représente le rang d'une carte à jouer
    type Rank =
        /// Représente le rang des cartes 2 .. 10
        | Value of int
        | Ace
        | King
        | Queen
        | Jack
        static member GetAllRanks() =
            [ yield Ace
              for i in 2 .. 10 do yield Value i
              yield Jack
              yield Queen
              yield King ]
                                 
    type Card =  { Suit: Suit; Rank: Rank }
             
    /// Renvoie une liste représentant un jeu de cartes complet
    let fullDeck =
        [ for suit in [ Hearts; Diamonds; Clubs; Spades] do
              for rank in Rank.GetAllRanks() do
                  yield { Suit=suit; Rank=rank } ]

    /// Convertit un objet 'Card' en chaîne
    let showCard c =
        let rankString =
            match c.Rank with
            | Ace -> "Ace"
            | King -> "King"
            | Queen -> "Queen"
            | Jack -> "Jack"
            | Value n -> string n
        let suitString =
            match c.Suit with
            | Clubs -> "clubs"
            | Diamonds -> "diamonds"
            | Spades -> "spades"
            | Hearts -> "hearts"
        rankString  + " of " + suitString

    let printAllCards() =
        for card in fullDeck do
            printfn "%s" (showCard card)
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:44

Code:
// ---------------------------------------------------------------
//        Les types d'options
// ---------------------------------------------------------------

module OptionTypes =
    /// Les valeurs d'option sont tout type de valeur marquée avec 'Some' ou 'None'.
    /// Elles sont très utilisées dans le code F# pour représenter les cas où de nombreux autres
    /// langages utilisent des références null.

    type Customer = { zipCode : decimal option }

    /// Classe abstraite qui calcule la zone d'expédition correspondant au code postal du client,
    /// en fonction des implémentations des méthodes abstraites 'getState' et 'getShippingZone'.
    [<AbstractClass>]
    type ShippingCalculator =
        abstract getState : decimal -> string option
        abstract getShippingZone : string -> int

        /// Renvoie la zone d'expédition correspondant au code postal du client
        /// Il se peut que le client ne dispose pas encore de code postal ou que ce dernier ne soit pas valide
        member this.customerShippingZone(customer : Customer) =
            customer.zipCode |> Option.bind this.getState |> Option.map this.getShippingZone
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:44

Code:
// ---------------------------------------------------------------
//        Les critères spéciaux
// ---------------------------------------------------------------

module PatternMatching =

    /// Enregistrement contenant le nom et le prénom d'une personne
    type Person = {   
        First : string
        Last  : string
    }

    /// définissez le type union discriminé de 3 types d'employés différents
    type Employee =
        | Engineer  of Person
        | Manager  of Person * list<Employee>            // le responsable dispose d'une liste de rapports
        | Executive of Person * list<Employee> * Employee // le cadre dispose d'un assistant

    /// comptez toutes les personnes placées sous cet employé dans la hiérarchie, y compris cet employé
    let rec countReports(emp : Employee) =
        1 + match emp with
            | Engineer(id) ->
                0
            | Manager(id, reports) ->
                reports |> List.sumBy countReports
            | Executive(id, reports, assistant) ->
                (reports |> List.sumBy countReports) + countReports assistant


    /// recherchez tous les responsables ou cadres dont le prénom est "Dave" et qui ne disposent d'aucun rapport
    let rec findDaveWithOpenPosition(emps : Employee list) =
        emps
        |> List.filter(function
                      | Manager({First = "Dave"}, []) -> true      // [] correspond à la liste vide
                      | Executive({First = "Dave"}, [], _) -> true
                      | _ -> false)                                // '_' est un caractère générique pouvant correspondre à n'importe quel élément
                                                                    // ceci permet de gérer le cas "or else"
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:44

Code:
// ---------------------------------------------------------------
//        Les unités de mesure
// ---------------------------------------------------------------

module UnitsOfMeasure =

    // Le code peut être annoté à l'aide d'unités de mesure lors de l'utilisation de l'arithmétique F# sur les types numériques

    open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames

    [<Measure>]
    type mile =
        /// Facteur de conversion de miles en mètres : le mètre est défini dans SI.UnitNames
        static member asMeter = 1600.<meter/mile>

    let d  = 50.<mile>          // Distance exprimée en unités impériales
    let d2 = d * mile.asMeter  // Même distance exprimée en utilisant le système métrique

    printfn "%A = %A" d d2
    // let error = d + d2      // Erreur de compilation : les unités de mesure ne sont pas les mêmes
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:45

Code:
// ---------------------------------------------------------------
//        La programmation parallèle de tableaux
// ---------------------------------------------------------------

module ParallelArrayProgramming =
             
    let oneBigArray = [| 0 .. 100000 |]
   
    // effectuez un calcul nécessitant une  utilisation importante du processeur
    let rec computeSomeFunction x =
        if x <= 2 then 1
        else computeSomeFunction (x - 1) + computeSomeFunction (x - 2)
     
    // Effectuez un mappage parallèle sur un tableau d'entrée de taille importante
    let computeResults() = oneBigArray |> Array.Parallel.map (fun x -> computeSomeFunction (x % 20))

    printfn "Parallel computation results: %A" (computeResults())
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:45

Code:
// ---------------------------------------------------------------
//        L'utilisation des événements
// ---------------------------------------------------------------

module Events =

    open System

    // créez une instance d'un objet Event constitué d'un point d'abonnement (event.Publish) et d'un déclencheur d'événements (event.Trigger)
    let simpleEvent = new Event<int>()

    // gestionnaire d'ajout
    simpleEvent.Publish.Add(
        fun x -> printfn "this is handler was added with Publish.Add: %d" x)

    // déclencheur d'événements
    simpleEvent.Trigger(5)

    // créez une instance Event répondant à la convention .NET standard suivante : (sender, EventArgs)
    let eventForDelegateType = new Event<EventHandler, EventArgs>()   

    // gestionnaire d'ajout
    eventForDelegateType.Publish.AddHandler(
        EventHandler(fun _ _ -> printfn "this is handler was added with Publish.AddHandler"))

    // déclencheur d'événements (notez que l'argument sender doit être défini)
    eventForDelegateType.Trigger(null, EventArgs.Empty)
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:45

Code:
// ---------------------------------------------------------------
//        L'accès aux bases de données à l'aide de fournisseurs de types
// ---------------------------------------------------------------

module DatabaseAccess =
             
    // Le moyen le plus facile d'accéder à une base de données SQL en F# est d'utiliser des types de fournisseurs F#.
    // Ajoutez des références à System.Data, System.Data.Linq et FSharp.Data.TypeProviders.dll.
    // Vous pouvez utiliser l'Explorateur de serveurs pour créer votre ConnectionString.

    (*
    #r "System.Data"
    #r "System.Data.Linq"
    #r "FSharp.Data.TypeProviders"

    open Microsoft.FSharp.Data.TypeProviders
   
    type SqlConnection = SqlDataConnection<ConnectionString = @"Data Source=.\sqlexpress;Initial Catalog=tempdb;Integrated Security=True">
    let db = SqlConnection.GetDataContext()

    let table =
        query { for r in db.Table do
                select r }
    *)


    // Vous pouvez également utiliser SqlEntityConnection à la place de SqlDataConnection, qui permet d'accéder à la base de données avec Entity Framework.

    ()
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Milly

avatar

Niveau 18
Niveau 18


Messages : 148
Côte : -312
Reputation : 0
Date d'inscription : 02/11/2009
Age : 25

MessageSujet: Re: [Tutoriel] Base du langage F#   Ven 17 Aoû - 20:45

Code:
// ---------------------------------------------------------------
//        L'accès aux données OData à l'aide de fournisseurs de types
// ---------------------------------------------------------------

module OData =

    (*
    open System.Data.Services.Client
    open Microsoft.FSharp.Data.TypeProviders

    // Utilisez le service OData d'Azure Marketplace relatif à la population et aux revenus.
    // Pour plus d'informations, consultez http://go.microsoft.com/fwlink/?LinkId=239712
    type Demographics = Microsoft.FSharp.Data.TypeProviders.ODataService<ServiceUri = "https://api.datamarket.azure.com/Esri/KeyUSDemographicsTrial/">
    let ctx = Demographics.GetDataContext()

    // Inscrivez-vous pour obtenir un compte Azure Marketplace depuis https://datamarket.azure.com/account/info
    ctx.Credentials <- System.Net.NetworkCredential ("<your liveID>", "<your Azure Marketplace Key>")

    let cities = query {
        for c in ctx.demog1 do
        where (c.StateName = "Washington")
        }

    for c in cities do
        printfn "%A - %A" c.GeographyId c.PerCapitaIncome2010.Value
    *)

    ()

Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Contenu sponsorisé







MessageSujet: Re: [Tutoriel] Base du langage F#   

Revenir en haut Aller en bas
 
[Tutoriel] Base du langage F#
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
Oz-Projects :: Téléchargements :: Bout de Code-
Sauter vers: