Konwersja operatorzy # rurociągów F (<|, >>, <<), aby SML

Question

mam przeliczania niektórych F # kod do SML i widzę wiele zastosowań tego operatora rurociągu <|, na przykład:

let printPeg expr = 
    printfn "%s" <| pegToString expr 

<| operator jest zdefiniowany jako tylko pozornie:

# let (<|) a b = a b ;; 
val (<|) : ('a -> 'b) -> 'a -> 'b = <fun> 

Zastanawiam się, dlaczego przeszkadza zdefiniować i użyć tego operatora w F #, to jest po prostu, aby mogli unikać umieszczania w parens jak to ?:

let printPeg expr = 
    Printf.printf "%s" (pegToString expr) 

O ile mogę powiedzieć, to byłaby konwersja powyższego kodu F # na OCaml, prawda?

Ponadto, w jaki sposób mogę zaimplementować operatory F # z << i >> w Ocaml?

(operator |> wydaje się być po prostu: let (|>) a b = b a ;;)

Answer 1

Bezpośrednio z F# source:

let inline (|>) x f = f x 
let inline (||>) (x1,x2) f = f x1 x2 
let inline (|||>) (x1,x2,x3) f = f x1 x2 x3 
let inline (<|) f x = f x 
let inline (<||) f (x1,x2) = f x1 x2 
let inline (<|||) f (x1,x2,x3) = f x1 x2 x3 
let inline (>>) f g x = g(f x) 
let inline (<<) f g x = f(g x) 

Answer 2

dlatego starał się zdefiniować i użyć tego operatora w F #, to tylko dlatego można uniknąć wprowadzania parens?

To dlatego, że funkcjonalny sposób programowania zakłada gwintowanie wartości przez łańcuch funkcji. Porównaj:

let f1 str server = 
    str 
    |> parseUserName 
    |> getUserByName server 
    |> validateLogin <| DateTime.Now 

let f2 str server = 
    validateLogin(getUserByName(server, (parseUserName str)), DateTime.Now) 

W pierwszym ujęciu wyraźnie widzimy wszystko, co dzieje się z wartością. Czytając drugi, musimy przejść przez wszystkie pareny, aby dowiedzieć się, co się dzieje.

This article o składzie funkcji wydaje się być istotne.

Tak, tak w zwykłym życiu chodzi głównie o pareny. Ale także operatorzy rurociągów są ściśle powiązani z aplikacją funkcji cząstkowych i bez-punktowym stylem kodowania. Zobacz np. Programming is "Pointless".

Rurociąg |> i funkcja skład >><< operatorzy mogą produkować kolejny ciekawy efekt, gdy są one przekazywane do funkcji wyższego poziomu, jak here.

Answer 3

Baterie OCaml obsługuje tych operatorów, ale ze względu na pierwszeństwo, asocjatywność i inne dziwactwa składniowe (jak Camlp4) używa różnych symboli. Które z używanych symboli zostało niedawno ustalone, są pewne zmiany. Patrz: Batteries API:

val (|>) : 'a -> ('a -> 'b) -> 'b 

Zastosowanie funkcji. x |> f jest równoważne f x.

val (**>) : ('a -> 'b) -> 'a -> 'b 

Zastosowanie funkcji. f **> x jest równoważne f x. Uwaga Nazwa tego operatora nie jest zapisana w kamieniu. Wkrótce się to zmieni.

val (|-) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c 

Skład funkcji. f | - g jest zabawne x -> g (f x). Jest to równoznaczne z dwukrotnym zastosowaniem < **.

val (-|) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b 

Skład funkcji. f - | g jest zabawne x -> f (g x). Matematycznie jest to operator o.

Ale Batteries trunk zapewnia: stosowanie

val (@@) : ('a -> 'b) -> 'a -> 'b 

Function. [f @@ x] jest równoważne [f x].

val (%) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b 

Skład funkcji: operator matematyczny [o].

val (|>) : 'a -> ('a -> 'b) -> 'b 

Aplikacja "rura": funkcja. [x |> f] jest równoważne [f x].

val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c 

Skład funkcji rurociągów. [f%> g] to [zabawa x -> g (fx)].

Answer 4

Zastanawiam się, dlaczego zawracają sobie głowy definiowaniem i używaniem tego operatora w F #, czy to jest tak, aby mogli uniknąć umieszczania parensów w ten sposób?

Doskonałe pytanie. Określony operator, do którego się odwołujesz (<|) jest dość bezużytecznym edytorem IME. Pozwala na unikanie nawiasów przy rzadkich okazjach, ale generalnie komplikuje składnię, przeciągając więcej operatorów i sprawia, że ​​trudniej jest dla mniej doświadczonych programistów F # (których jest teraz wielu), aby zrozumieć twój kod. Więc przestałem go używać.

Operator |> jest o wiele bardziej przydatny, ale tylko dlatego, że pomaga F # poprawnie wnioskować o typach w sytuacjach, w których OCaml nie miałby problemu. Na przykład, oto niektóre OCaml:

List.map (fun o -> o#foo) os 

Bezpośrednią odpowiednik nie w F #, ponieważ typ o nie można wnioskować przed odczytaniem jej foo własność więc idiomatyczne rozwiązaniem jest przepisać kod tak użyciu |> tak F # można wywnioskować typ o przed foo służy:

os |> List.map (fun o -> o.foo) 

rzadko używać innych operatorów (<< i >>), ponieważ również skomplikować składnię. Nie lubię też bibliotek kombinatorycznych parserów, które przyciągają wielu operatorów.

Przykład Bytebuster dało to ciekawy:

let f1 str server = 
    str 
    |> parseUserName 
    |> getUserByName server 
    |> validateLogin <| DateTime.Now 

chciałbym napisać to jako:

let f2 str server = 
    let userName = parseUserName str 
    let user = getUserByName server userName 
    validateLogin user DateTime.Now 

Brak wsporniki w moim kodu. Moje tymczasowe mają nazwy, więc pojawiają się w debugerze i mogę je sprawdzić, a Intellisense może dać mi zwrot w stylu, gdy najecham na nie myszą.Te cechy są cenne dla kodu produkcyjnego, który będą utrzymywać niefachowcy F #.