Sémantique de l'opérateur « >> » en F #

Question

Dans échantillons F # , ils utilisent l'opérateur ">>" comme suit:

test |> Seq.iter (any_to_string >> printfn "line %s");

Qu'est-ce que l'opérateur « >> » faire dans ce contexte? Est chaque élément de la séquence (un tableau dans ce cas) être transmis au implicitement any_to_string? Est-ce similaire à (fun item -> printfn "line %A" item)?

Answer 1

Un morceau de code équivalent pourrait être écrit de la manière suivante:

test |> Seq.iter(fun x -> printfn "line %s" (any_to_string x))

En d'autres termes, le >> opérateur fait simplement ceci: étant donné une fonction f (x) retour type T et g (y) avec y être de type T, vous pouvez utiliser f >> g pour créer une fonction h ( z) étant équivalente à g (f (x)). Aucun argument, mais la fonction intérieure et extérieure doit être transmis à cet opérateur et le résultat est une fonction qui peut être appliquée à tout moment dans votre code, vous pouvez donc faire ceci:

//myFunc accepts any object, calls its ToString method, passes ToString
//result to the lambda which returns the string length. no argument is
//specified in advance
let myFunc = any_to_string >> (fun s -> s.Length)
let test = 12345
let f = 12345.0
//now we can call myFunc just like if we had definied it this way:
//let myFunc (x:obj) = obj.ToString().Length
printfn "%i" (myFunc i)
printfn "%i" (myFunc f)

Answer 2

(>>) est une fonction d'ordre supérieur qui prend deux fonctions (avec des arguments compatibles) et combinés ( « compose ») entre eux dans une fonction.

Par exemple, avec

let len (s : string) = s.Length
let show (n : int) = n.ToString()

La ligne

(show >> len) 15

est équivalent à

len (show 15)

ainsi que

show 15 |> len

Answer 3

La définition à

http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/FSharp.Core/Microsoft.FSharp.Core.Operators.html

dit

val ( >> ) : ('a -> 'b) -> ('b -> 'c) -> ('a -> 'c)
//Compose two functions, the function on the left being applied first

Mais j'espère que d'autres fourniront une explication plus approfondie.

EDIT

doc MSDN maintenant

http://msdn.microsoft.com/ fr-fr / bibliothèque / ee353825 (VS.100) .aspx

Answer 4

Il est un opérateur de composition de fonction (comme décrit dans les autres messages)

Vous pouvez définir cet opérateur par vous-même afin de voir sa sémantique:

let (>>) f g = fun x -> g (f x)

Answer 5

Cela peut être d'aucune aide si vous êtes mal à l'aise avec C #, génériques ou lambdas, mais voici un équivalent en C #:

//Takes two functions, returns composed one
public static Func<T1, T2> Compose<T1, T2, T3>(this Func<T1, T2> f, Func<T2, T3> g)
{
    return (x) => g(f(x));
}

En regardant les paramètres de type lit quelque chose comme la réponse de Brian:

Compose prend une fonction qui va de T1 à T2, et un autre qui va de T2 à T3, et retourne la combinaison des deux, qui va de T1 à T3.

Answer 6

L'opérateur effectue >> composition de fonction, qui est tout à fait bien expliqué sur Wikipedia . Dustin Campbell offre une grande utilité pour elle et explique (en même temps que l'opérateur |> (tuyau avant)) sur son blog .