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

Oz-Projects

Oz-Projects, les applications qu'il faut Ozer !
 
AccueilFAQRechercherMembresGroupesS'enregistrerConnexion
Oz-Projects entreprend un partenariat avec la guilde du Royaume de Serrah.

Cette organisation est une guilde du jeu Dofus basée sur le serveur de Brumen qui accueilles les joueurs peu importe leur expérience sur le jeu ou leur niveau.

L'objectif de ce partenariat est que la guilde peut proposer des applications qui seront catégorisée #Dofus selon leur besoins.
Partenaire officiel d'Oz-Projects, la FloZon est un serveur Discord convivial gaming et détente. N'hésitez pas à venir y faire un tour et découvrir sa communauté ! https://discord.gg/jsPZ4Vv

Partagez
 

 [Tutoriel] Base du langage F#

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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
Oz-Projects

Oz-Projects

Niveau 18
Niveau 18


Messages : 165
Côte : -508
Reputation : 0
Date d'inscription : 02/11/2009

[Tutoriel] Base du langage F# Empty
MessageSujet: Re: [Tutoriel] Base du langage F#   [Tutoriel] Base du langage F# Icon_minitimeVen 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é







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

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
 Sujets similaires
-
» [MOC] Base Xion
» Livre de base + supplément Cadwallon à vendre
» [Revues] Tutoriel : Faire une bonne photo et la poster
» [Tutoriel] Colorisation
» Boite de base V8 sur Wayland

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: