Pomaga to ukończyć zdjęcie scenariuszy krojenia tablic 3D i 4D.

Podgląd: indeksy odwrotne

Microsoft wprowadza również możliwość korzystania z indeksów odwrotnych, których można użyć z plasterkami, jako podgląd w F# 5. Aby go użyć, po prostu umieść zapowiedź w pliku projektu.

Niech xs = [1..10] // Uzyskaj element 1 od końca: xs.[^1] // stary sposób na zdobycie dwóch ostatnich elementów niech LastWooldStyle = xs.[(XS.Długość 2)..] // nowy sposób na uzyskanie dwóch ostatnich elementów niech LastTWoneWstyle = xs.[^1..] lastWooldStyle = lastTWoneWstyle // true 

Możesz także zdefiniować własnych członków za pośrednictwem rozszerzenia typu F# w celu zwiększenia tych typów, aby obsługiwać indeksy krojenia i odwrotnego. Poniższy przykład z typem rozpiętości:

Otwórz rozpiętość typu systemu z członkiem SP.Getslice (startidx, endidx) = let s = defaultArg startidx 0 niech e = DefaultArg endidx sp SP.Długość sp.Slice (s, e - s) członek sp.GetReverseIndex (_, offset: int) = sps.Długość - Offset Niech sp = [| 1; 2; 3; 4; 5 |].Asspan () sp.[[[..^2] // [| 1; 2; 3 |] 

F# typy wewnętrzne mają wbudowane indeksy odwrotne. W przyszłej wersji F#będziemy również obsługiwać pełną interop z systemem.Indeks i system.Zakres, w którym to momencie funkcja nie będzie już podgląd.

Ulepszone cytaty kodu

F# Cytaty kodu są funkcją metaprogrammowania, która pozwala manipulować strukturą kodu F# i ocenić ją w środowisku wybranego. Ta zdolność jest niezbędna do wykorzystania F# jako modelu języka budowy do zadań uczenia maszynowego, w którym model AI może działać na różnych sprzętach, takich jak GPU. Krytycznym elementem brakującym w tej układance była zdolność wiernego reprezentowania informacji o ograniczeniu typu F#, takich jak te używane w arytmetyce ogólnej, w cytacie F#, aby ewaluator mógł wiedzieć, aby zastosować te ograniczenia w środowisku, w którym ocenia.

Począwszy od F# 5, ograniczenia są teraz zachowywane w cytatach kodu, odblokowując zdolność niektórych bibliotek, takich jak diffsharp do użycia tej części systemu typu F# na swoją korzyść. Prostym sposobem wykazania, że ​​jest to następujący kod:

Otwórz fsharp.Linq.RuntimeHelpers Let Eval Q = LeafExpressionConverter .Ocena q Niech inline neguj x = -x // Co najważniejsze, „negate” ma // następujący podpis: // // val inline neguj: // x: ^a -> ^a // Kiedy ^a: // (członek statyczny (~ -): ^a -> ^a) // // To ograniczenie jest krytyczne do bezpieczeństwa typu f# // i jest teraz zachowane w cytatach . |> eval 

Zastosowanie operatora arytmetycznego implikuje ograniczenie typu, tak że wszystkie typy przekazane w celu negowania musi obsługiwać ? operator. Ten kod nie kończy się w czasie wykonywania, ponieważ cytat kodu nie zachowuje tych informacji o ograniczeniu, więc ocena jej wyświetla wyjątek.

Cytaty kodu są podstawą dla niektórych innych prac na rzecz badań i d, które są wykonywane w celu użycia F# jako języka do tworzenia modeli AI, a zatem możliwość zachowania w nich informacji o ograniczeniu typu pomaga uczynić F# przekonujący język dla programistów w tej przestrzeni, którzy szukają nieco więcej bezpieczeństwa w swoim życiu w życiu.

F# 5 ma wielkie podstawy

F# 5 może polegać na lepszym ulepszaniu interaktywności i programów analityczny. F# 5 zawiera kilka nowych funkcji, które mogą cieszyć się zarówno twórcy aplikacji, jak i autorzy biblioteki.

Obsługa nazwy

First Up jest funkcją, którą C# Dewelopers przyszli na pokochanie: Nameof . Nazwa operatora przyjmuje symbol f# jako wejście i wytwarza ciąg w czasie kompilacji, który reprezentuje ten symbol. Obsługuje prawie wszystkie konstrukty F#. Nazwa operatora jest często używana do rejestrowania diagnostyki w uruchomionej aplikacji.

#R "Nuget: Fsharp.SystemTextJson &bdquo;Otwarty system.Tekst.System otwartego JSON.Tekst.JSON.System otwarty serializacji.Czas wykonawczy.Moduł CompilerServices M = LET F X = Nazwa x printfn "%s" (m.f 12) printfn &bdquo;%s&rdquo; (nameof m) printfn &bdquo;%s&rdquo; (nameof m.f) /// Uproszczona wersja typu API EventStore Neordevent = < EventType: string Data: byte[] >/// Mój konkretny typ: Type MyEvent = | Adata of Int | BData z String // Użyj &bdquo;nameof&rdquo; zamiast literału ciągów w wyrażeniu dopasowania Niech Deserialize (E: Nagrywanie): MyEvent = Match E.EventType z | Nazwa ADATA -> JSOSSERIALIZER.Deserializuj e.Dane |> Adata | Nazwa Bdata -> JsonSerializer.Deserializuj e.Dane |> Bdata | t -> failWithf &bdquo;Nieprawidłowy typ zdarzenia: %s&rdquo; t 

Interpolowane sznurki

Dalej jest funkcja widoczna w językach takich jak C# i JavaScript: Interpolated Strings. Interpolowane ciągi umożliwiają tworzenie interpolacji lub otworów w ciągu, który można wypełnić dowolnym wyrażeniem F#. F# interpolowane ciągi obsługują wpisane interpolacje synonimowe z tym samym formatem Określa w formatach SPRINTF i Printf Strings. F# interpolowane sznurki obsługują również struny potrójne. Podobnie jak w C#, wszystkie symbole w interpolacji F# są żeglowani, można je przemianować i tak dalej.

// Podstawowy interpolowany ciąg niech nazwa = "phillip" Niech wiek = 29 Niech message = $ "Nazwa:, wiek:" // maszyna interpolacja // ' %s' wymaga, aby interpolacja jest ciągiem // ' %d' Wymaga interpolacji, aby interpolacja była komunikatem. „” „„ Nazwa ”:„ ”,„ wiek ”:„ ”” 

Dodatkowo możesz zapisać wiele wyrażeń wewnątrz interpolowanych ciągów, wytwarzając inną wartość dla interpolowanego wyrażenia w oparciu o wejście do funkcji. Jest to bardziej niszowe użycie tej funkcji, ale ponieważ każda interpolacja może być ważnym wyrażeniem F#, pozwala na dużą elastyczność.

Deklaracje typu otwartych

F# zawsze pozwolił ci otworzyć przestrzeń nazw lub moduł, aby ujawnić swoje publiczne konstrukcje. Teraz, z F# 5, możesz otworzyć dowolny typ, aby odsłonić konstrukty statyczne, takie jak metody statyczne, pola statyczne, właściwości statyczne i tak dalej. F# Union and Records można również otworzyć. Możesz także otworzyć typ ogólny przy określonym typie instancji.

system typu otwartego.Matematyka niech x = min (1.0, 2.0) Moduł M = typ du = a | B | C Niech jakaś funkcja x = x + 1 // otworzy tylko typ wewnątrz modułu typu otwartego m.Du printfn „%a” a 

Ulepszone wyrażenia obliczeniowe

Wyrażenia obliczeniowe to ukochany zestaw funkcji, które pozwalają autorom biblioteki pisać ekspresyjny kod. Dla tych, którzy są w teorii kategorii, są one również formalnym sposobem pisania obliczeń monadycznych i monoidalnych. F# 5 rozszerza wyrażenia obliczeniowe o dwie nowe funkcje:

• Formularze aplikacyjne do wyrażeń obliczeniowych za pośrednictwem Let. I! słowa kluczowe
• Właściwe wsparcie dla przeciążenia operacje niestandardowe

“Formularze aplikacyjne do wyrażeń obliczeniowych” to trochę kęs. Unikię nurkowania w teorii kategorii i zamiast tego przeprowadzę przykład:

// Najpierw zdefiniuj wynik modułu funkcji &bdquo;ZIP&rdquo; = niech Zip x1 x2 = dopasuj x1, x2 z | OK X1RES, OK X2RES -> OK (X1RES, X2RES) | Błąd E, _ -> Błąd E | _, Błąd e -> błąd e // Dalej zdefiniuj konstruktora z &bdquo;mergesources&rdquo; i &bdquo;bindreturn&rdquo; type wynik () = członek _.Mergesources (T1: wynik, t2: wynik) = wynik.Członek zip t1 t2 _.Bindreturn (x: wynik, f) = wynik.Mapa f x let wynik = wynik Builder () Niech uruchom r1 r2 r3 = // i oto nasza aplikacja! Niech res1: wynik = wynik < let! a = r1 and! b = r2 and! c = r3 return a + b - c >mecz res1 z | OK x -> printfn " %s Is: %d" (Nameof Res1) x | Błąd e -> printfn " %s Is: %s" (nameof res1) e 

Przed F# 5, każdy z nich i! Słowa kluczowe byłyby wypuszczone! słowa kluczowe. I! Słowo kluczowe różni się tym, że następujące wyrażenie musi być w 100% niezależne. Nie może to zależeć od wyniku poprzedniego letnia! -Związana wartość. Oznacza to kod taki jak następujące, nie kompiluje:

Niech res1: wynik = wynik < let! a = r1 and! b = r2 a // try to pass 'a' and! c = r3 b // try to pass 'b' return a + b - c >

Dlaczego więc mielibyśmy sprawić, że ten kod nie kompiluje? Kilka powodów. Po pierwsze, egzekwuje niezależność obliczeniową w czasie kompilacji. Po drugie, kupuje niewielką wydajność w czasie wykonywania, ponieważ pozwala kompilatorowi opracować wykres połączenia statycznie. Po trzecie, ponieważ każde obliczenia jest niezależne, mogą być wykonywane równolegle przez dowolne środowisko, w którym działają. Wreszcie, jeśli obliczenia się nie powiedzie, na przykład w poprzednim przykładzie, w którym można zwrócić wartość błędu zamiast wartości OK, cała sprawa nie zwraca się do tej awarii. Formularze aplikacyjne “zebrać” Wszystkie wynikowe wartości i umożliwić każdemu obliczeniom uruchomienie przed zakończeniem. Jeśli miałbyś wymienić każdy i! Z LET! , Każdy, kto zwrócił błąd zwarci z funkcji. To różne zachowanie pozwala autorom biblioteki i użytkownikom wybrać odpowiednie zachowanie w oparciu o ich scenariusz.

Jeśli to brzmi, jakby to trochę ciężkie, to w porządku! Obliczenia aplikacyjne to nieco zaawansowana koncepcja z punktu widzenia autora biblioteki, ale są potężnym narzędziem do abstrakcji. Jako użytkownik nie musisz znać wszystkich tajników, jak działają; Możesz po prostu wiedzieć, że każde obliczenia w wyrażeniu obliczeń jest gwarantowane niezależnie od innych.

Kolejnym ulepszeniem wyrażeń obliczeniowych jest możliwość prawidłowego obsługi przeciążenia dla operacji niestandardowych o tej samej nazwie słowa kluczowego, obsłudze opcjonalnych argumentów i obsłudze systemu.Argumenty paramarray. Niestandardowa operacja jest sposobem dla autora biblioteki do określenia specjalnego słowa kluczowego, które reprezentuje ich własny rodzaj operacji, które może się zdarzyć w wyrażeniu obliczeń. Ta funkcja jest często używana w ramach takich jak Saturn do zdefiniowania ekspresyjnego DSL do budowania aplikacji internetowych. Począwszy od F# 5, autorzy komponentów takich jak Saturn mogą przeciążać swoje niestandardowe operacje bez żadnych zastrzeżeń, jak pokazano w Lista 1.

Lista 1: Wyrażenia obliczeniowe mogą przeciążyć operacje niestandardowe

Typ inputKind = | Tekst zastępcy: opcja ciągów | Hasło zastępczego: < Label: string option Kind: InputKind Validators: (string ->bool) tablica> typ inputBuilder () = członek t.Wydajność (_) = < Label = None Kind = Text None Validators = [||] >[] członek tego.Tekst (io,?zastępca) = < io with Kind = Text placeholder >[] członek tego.Hasło (IO,?zastępca) = < io with Kind = Password placeholder >[] członek tego.Etykieta (io, etykieta) = < io with Label = Some label >[] członek tego.Walidacze (IO, [] walidacje) = < io with Validators = validators >Let Input = InputBuilder () Let Name = Input < label "Name" text with_validators (String.IsNullOrWhiteSpace >> nie)> Pozwól e -mail = wprowadzenie < label "Email" text "Your email" with_validators (String.IsNullOrWhiteSpace >> nie) (zabawne s -> s.Zawiera &bdquo;@&rdquo;)> pozwól hasło = wejście < label "Password" password "Must contains at least 6 characters, one number and one uppercase" with_validators (String.exists Char.IsUpper) (String.exists Char.IsDigit) (fun s ->S.Długość> = 6)> 

Właściwe wsparcie dla przeciążeń w operacjach niestandardowych są opracowywane w całości przez dwóch współpracowników F# Open Source Diego Esmerio i Ryan Riley.

Dzięki formularzom aplikacyjnym do wyrażeń obliczeniowych i możliwości przeciążenia niestandardowych operacji, jesteśmy podekscytowani, aby zobaczyć, co autorzy biblioteki F# mogą zrobić dalej.

Implementacje interfejsów przy różnych ogólnych instancjach

Począwszy od F# 5, możesz teraz zaimplementować ten sam interfejs przy różnych ogólnych instancjach. Ta funkcja została opracowana we współpracy z Lukas Rieger, współpracownik F# Open Source.

Typ IA = Streszczenie Członek Get: Jednostka -> ?T typ myClass () = interfejs IA z członkiem x.Get () = 1 interfejs IA z członkiem x.Get () = "hello" let mc = myClass () let asint = mc:> ia let aststring = mc:> ia asint.Get () // 1 Asstring.Get () // „Hello” 

Więcej .Ulepszenia międzynarodowe netto

.Net to ewoluująca platforma, z nowymi koncepcjami wprowadzonymi w każde wydanie, a tym samym więcej możliwości interperacji. Interfejsy w .Net może teraz określić domyślne implementacje dla metod i właściwości. F# 5 pozwala bezpośrednio spożywać te interfejsy. Rozważ następujący kod C#:

za pomocą systemu; Przestrzeń nazw csharplibrary < public interface MyDim < public int Z =>0; >> 

Ten interfejs można zużywać bezpośrednio w F#:

Otwórz CSHARP // Utwórz wyrażenie obiektowe, aby zaimplementować interfejs niech MD = < new MyDim >printfn $ &bdquo;Dim from C#:&rdquo; 

Kolejna koncepcja w .Netto, która zyskuje więcej uwagi, to zerowe typy wartości (wcześniej nazywane typy zerowych). Początkowo utworzone w celu lepszego reprezentowania typów danych SQL, są one również fundamentalne dla bibliotek manipulacji danymi podstawowymi, takimi jak abstrakcja ramki danych w Microsoft.Dane.Analiza . Aby ułatwić interopowanie z tymi bibliotekami, zastosujesz nową regułę skierowaną do typu do wywoływania metod i przypisywania wartości do właściwości, które są typem wartości zerowej. Rozważ następującą próbkę przy użyciu tego pakietu z dyrektywą referencyjną pakietu:

#R "Nuget: Microsoft.Dane.Analiza „Otwórz system otwarty Microsoft.Dane.Analiza pozwól datetimes = "dateTimes" |> PrimitivedAframeColumn // Poniższe użyte do skompilowania let date = dateTime.Parse („2019/01/01”).Append (data) // poprzednie jest teraz równoważne: let date = dateTime.Parse („2019/01/01”) niech data = nullable (data).Dodatek (dane) 

Przykłady te wymagane do jawnego konstruowania typu wartości zerowej z konstruktorem typu zerowego, jak pokazuje przykład.

Lepsza wydajność

Zespół Microsoft spędził miniony rok na poprawie wydajności kompilatora F# zarówno pod względem przepustowości, jak i wydajności narzędzi w IDES, takich jak Visual Studio. Te ulepszenia wydajności rozwinęły się stopniowo, a nie jako część jednego dużego wydania. Suma tej pracy, która kończy się w F# 5, może mieć znaczenie dla codziennego programowania F#. Jako przykład skompilowałem tę samą bazę kodu ? Podstawowy projekt w Fsharplus, projekt, który notorycznie podkreśla kompilator F# ? trzy razy. Raz na f# 5, raz na najnowszy f# 4.7 z .Rdzeń netto i raz na najnowszy f# 4.5 cali .Rdzeń netto, jak pokazano w Tabela 1.

Wyniki Tabela 1 Pochodzą z uruchamiania Dotnet Build /CLP: PerformanceUnNary z wiersza poleceń i patrzenie na całkowity czas spędzony w zadaniu FSC, którym jest kompilator F#. Wyniki mogą się różnić na twoim komputerze w zależności od takich rzeczy, jak priorytet procesu lub praca w tle, ale powinieneś zobaczyć mniej więcej ten sam spadek czasów kompilacji.

Wydajność IDE zwykle wpływa użycie pamięci, ponieważ IDE, podobnie jak Visual Studio, prowadzą kompilator w usłudze językowej jako długotrwały proces. Podobnie jak w przypadku innych procesów serwerowych, im mniej pamięci zużywasz się, tym mniej czasu GC spędza się na czyszczeniu starej pamięci i tym więcej czasu można spędzić przetwarzanie przydatnych informacji. Skoncentrowaliśmy się na dwóch głównych obszarach:

• Korzystanie z plików mapowanych na pamięć do popierania odczytu metadanych z kompilatora
• Ponowne architektowanie operacji, które znajdują symbole w rozwiązaniu, takie jak znajdź wszystkie odniesienia i zmień nazwę

Rezultatem jest znacznie mniejsze zużycie pamięci dla większych rozwiązań podczas korzystania z funkcji IDE. Rysunek 5 Pokazuje przykład użycia pamięci podczas uruchamiania Znajdź odniesienia do typu ciągów w fałszywym, bardzo dużej bazie kodu open source, przed wprowadzonymi zmianami.

Ta operacja zajmuje również minutę i 11 sekund, aby ukończyć po pierwszym czasie.

Z F# 5 i zaktualizowanymi narzędziami F# dla Visual Studio, ta sama operacja zajmuje 43 sekundy do zakończenia i wykorzystuje ponad 500 MB mniej pamięci, jak pokazano w Rysunek 6.

Przykład z wyników pokazanych w Rysunek 5 I Rysunek 6 jest ekstremalne, ponieważ większość programistów nie szuka zastosowań typu bazowego podobnego do ciągu w bardzo dużej bazie kodowej, ale pokazuje, ile lepszej wydajności używasz f# 5 i najnowsze narzędzia do F# w porównaniu z zaledwie rok temu.

Wydajność jest czymś, nad czym stale pracuje, a ulepszenia często pochodzą od naszych współpracowników open source. Niektóre z nich to Steffen Forkmann, Eugene Auduchinok, Chet Hust, Saul Rennison, Abel Braaksma, Isaac Abraham i więcej. Każde wydanie zawiera niesamowite prace autorów typu open source; Jesteśmy wiecznie wdzięczni za ich pracę.

Kontynuująca podróż i jak się zaangażować

Zespół Microsoft F# jest bardzo podekscytowany wydaniem F# 5 w tym roku i mamy nadzieję, że pokochasz to tak samo jak my. F# 5 reprezentuje dla nas początek nowej podróży. Patrząc w przyszłość, będziemy stale ulepszać interaktywne doświadczenia, aby F# był najlepszym wyborem dla notebooków i innych interaktywnych narzędzi. Będziemy głębiej projektować języki i nadal obsługiwać biblioteki takie. I jak zawsze, poprawimy się na podstawie kompilatora F#.

Chcielibyśmy też zobaczyć, jak przychodzisz na przejażdżkę. F# jest całkowicie open source, z sugestiami językowymi, projektowaniem języka i podstawowym rozwojem działającym na Github. Jest dziś kilku doskonałych współpracowników i szukamy więcej współpracowników, którzy chcą mieć udział w tym, jak ewoluują język i narzędzia F#.

Aby zaangażować się na poziomie technicznym, sprawdź następujące linki:

• F# Sugestie językowe: https: // github.COM/FSHARP/FSLANG-SUGGINGIONS
• F# Projekt języka: https: // github.com/fsharp/fslang-design
• F# Development: https: // github.com/dotnet/fsharp
• F# działający na JavaScript: https: // bajka.IO/
• F# Narzędzia do kodu Visual Studio: http: // jonid.IO/
• F# Uruchamianie w zespole internetowym: https: // fsBolero.IO/

Fundacja F# Software jest również gospodarzem dużej społeczności Slack, oprócz tego, że jest centralnym punktem dla różnych podgatunków do dzielenia się informacjami. Dołączanie do nich jest bezpłatne, więc udaj się na stronę tutaj, aby dowiedzieć się więcej: http: // fundacja.fsharp.org/dołącz

Chcę mieć coś do powiedzenia, gdzie F# idzie dalej i jak to robi? Chodź, dołącz do nas. Chcielibyśmy współpracować.

Notebooki Jupyter

Notebooki Jupyter to interaktywne narzędzie do programowania, które pozwala mieszać Markdown i kod w dokumencie. Kod można wykonać w notebookie, często w celu tworzenia ustrukturyzowanych danych lub wykresów, które idą w parze z wyjaśnieniem.

Notebooki Jupyter rozpoczęły się jako IPython, interaktywne narzędzie programowania programów Python. Wrócił do wspierania wielu różnych języków i jest obecnie jednym z głównych narzędzi używanych przez naukowców danych w ich pracy. Jest również używany jako narzędzie edukacyjne.

Tabela 1: Czasy kompilacji dla fsharpplus.DLL w najnowszych wersjach F#

F# Język programowania: historia, korzyści i przyszłe możliwości

NeScint Deweloperzy mogą popełnić błąd, wymawiając nazwę jako F ‘Haszysz’ Ale to przyniesie kilka pogardliwych oczu od Adept One w deweloperze’społeczność S. F Sharp (ponieważ # jest wymawiane jako ostre) to otwarty, silnie wpisany, multi-paradigmowy język programowania. Język programowania wielu paradygmatów obejmuje programowanie funkcjonalne, imperatywne i obiektowe

Każdy język programowania może należeć do jednej z dwóch kategorii; silnie wpisane i słabo wpisane.

Silnie wpisane języki mają wysoce uparte przepisy w czasie kompilacji, co sugeruje, że błędy i wyjątki są bardziej prawdopodobne. Większość tych przepisów wpływa na wartości zwrotne, przypisania zmiennych i wywoływanie funkcji.

Podczas gdy słabo wpisany język jest odwrotnie i ma luźne zasady pisania, które mogą przychylić nieprzewidywalne wyniki lub powodować konwersję niejawnych typów w czasie wykonywania.

Multi-paradigm odnosi się do obsługi więcej niż jednego paradygmatu programowania, aby umożliwić programistom wybór najbardziej odpowiedniego stylu programowania i powiązanych konstrukcji języka dla danego projektu.

Jest często używany jako CLI międzyplatformowe (infrastruktura języka wspólnego), a także może generować kod JavaScript i GPU (graficzna jednostka przetwarzania).

Jest opracowywany przez F# Software Foundation i Microsoft wraz z innymi otwartymi współpracownikami.

Krótka historia

F# pojawił się po raz pierwszy w 2005 roku, kiedy został opracowany przez Microsoft Research. Początkowo był to .Net (wymawiane jako DOT NET) Implementacja OCAML, ponieważ połączyła moc i składnię języka funkcjonalnego z tysiącami funkcji bibliotecznych dostępnych z .Języki netto.

Od 2005 r. F# przeszedł wiele potrzebnych zmian, a programiści stworzyli różne wersje, które uczyniły go lepszym niż pierwsza. Uruchamiając licencję Apache, uczyniło język programowania otwartym pochodzeniem, co oznaczało, że można go modyfikować, dystrybuować i używać bez płacenia oryginalnym programistom.

Pierwsza wersja uruchomiona w 2005 roku była tylko kompatybilna z systemem Windows i wdrożona .Netto 1.0 do 3.5 czas wykonawczy. Wąska baza platformy była największą słabością tej wersji. Problem został rozwiązany w następnej wersji, która została opracowana z dodaniem zarówno OS X, jak i Linux do obsługiwanych platform w wersji 2.0, który został uruchomiony w 2010 roku.
W 2012 r. F# zobaczył dodanie JavaScript i GPU na obsługiwanych platformach. Najnowsza wersja została uruchomiona w 2015 roku, która była 4.0.

Przyszłość F#

Wiele osób twierdzi, że F# jest jednym z najbardziej niepopularnych, niedocenianych i niedostatecznie reprezentowanych języków programowania. Ale jest inna strona historii. Według StackoverFlow. F# został uznany za język związany z najwyższą płacą na całym świecie.

Ta sama ankieta pokazuje, że F# czynn’t pojawiają się w 25 najlepszych językach programowania używanych na całym świecie. Język pozostaje na marginesie, mimo że ma naprawdę aktywną społeczność.

Ale dlaczego programiści uwielbiają pracować z F#, jeśli to’s tak niepopularny? Utworzone i utrzymane przez Dona Syme, F# był stosunkowo odporny na niektóre z zakładanych nadmiernych komplikacji, że podobne języki FP przyjęły, takie jak Scala. Ten opór utrzymuje dostępność dla programistów ze świata zewnętrznego, którzy mogą być zainteresowani dbaniem w programowanie funkcjonalne.

F# był doskonały, jeśli chodzi o rozwój opartych na danych i opartych na domenach. Teraz można go również skompilować w JavaScript, który jest światem’S najpopularniejsze języki. Dzięki temu linkowi bezpiecznemu ma również dostęp do JavaScript’S obszerne biblioteki i baza urządzeń.

F# odcisnął swoje piętno, jeśli chodzi o sztuczną inteligencję, uczenie maszynowe i powiązane analiza danych. To był cel stworzenia f#. Ze względu na ogromną skalę i oczekiwany wpływ sztuczna inteligencja będzie miała ogólnie ekosystemy językowe i technologię, mając język tak dobrze dostosowany do miejsc rozwojowych w silnej sytuacji, aby szybko rosnąć, a nawet kwestionować popularne języki, takie jak JavaScript i Python w przyszłości.

Co zatrzymuje F#’s wzrost?

Choć wydaje się to trudny fakt do strawienia, winę za to jest głównie przypisywana jej twórcom, czyli Microsoft. Ograniczyli popularność f# pozwalającym na rozkwit c#. Microsoft uczynił F# gorszy od C#.

Jest w tym cykliczny ruch. Niewiele zadań istnieje dla F#, ponieważ jest tam niewielu programistów F# i jest mniej programistów F#, ponieważ istnieje mniej zadań F#. Ale powoli, ale na pewno ten trend się zmienia.

Strumień.COM była pierwszą dużą firmą, która przyjęła wykorzystanie F#. Później śledzono także Kaggle i wiele firm finansowych i ubezpieczeniowych.

Twórcy F# brakuje prób uczynienia go bardziej popularnym i z funkcjami jako języka wieloosobowego, który jest bardzo używany w sztucznej inteligencji, najlepszą rzeczą jest skupienie się na podstawowych korzyściach F#, które są krótszymi czasami, mniej błędów i wyższą wydajność i wyższą wydajność. W przypadku awansu przez podkreślenie tych funkcji może pomóc F# wspiąć się na drabinę popularności szybciej niż wcześniej.

Czy f# naprawdę ma jakąkolwiek przewagę nad c#?

Już zaznajomiony z C#? Następnie naucz się zaprogramować własną grę przełomową za pomocą C#.

• F# sprawia, że ​​wiele powszechnych zadań programowania jest. Obejmuje to takie rzeczy, jak tworzenie i używanie złożonych definicji typów, przetwarzanie listy, maszyny stanowe, równość i porównanie i wiele więcej.
• Pozbawiony półkolisów, kręconych nawiasów i tym podobnych, prawie nigdy nie musisz określać typu obiektu ze względu na obecność silnego systemu wnioskowania typu. Rozwiązanie tego problemu wymaga również mniej linii kodów
• F# jest językiem funkcjonalnym, ale obsługuje inne style, które nie są’t całkowicie czyste, co znacznie ułatwia interakcję z niezbędną dziedziną baz danych, stron internetowych i tak dalej. W szczególności F# jest zaprojektowany jako funkcjonalny język hybrydowy/oo, więc jest w stanie zrobić wszystko jako c#. Mimo że F# płynnie integruje się z .Ekosystem netto, który pozwala uzyskać dostęp do wszystkich stron trzecich .Narzędzia i biblioteki netto.
• F# jest częścią Visual Studio, które pozwala uzyskać dobrego edytora z obsługą IntelliSense, debuggera i wieloma wtyczkami do testów jednostkowych, kontroli źródła i innych zadań programistycznych.

F# przyszłość

Podobne do asynchronizacji < >Blokuj, ale rejestruje wynik przyszłej konsumpcji. Ta struktura może być bardzo przydatna do równolegle wykonywania wielu operacji returowania wyników, gdy wyniki nie są potrzebne natychmiast. Na przykład wykonanie kilku operacji odczytu/transformacji lub wstępnego zapulującego pamięci podręcznej z wartościami obliczonymi. Biblioteka równoległa Microsoft w bibliotece .Netto 4.0 obejmuje przyszłą implementację, więc ta wersja jest potrzebna tylko wcześniej .Wersje netto. Komentarze, sugestie i ulepszenia są zawsze mile widziane.

 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 

otwarty System otwarty System.ComponentModel otwarty System.Gwintowanie /// Wykonuje obliczenia w pracownikach w tle i synchronizuje się w związku.  /// obliczenia są rozpoczynające się natychmiast i wywołuje blokuje &bdquo;wartość&rdquo;, aż wynik będzie gotowy. typ Przyszły'T>(F : jednostka -> 'T) = /// Wynik obliczenia na normalnym wyjściu. pozwalać zmienny wynik :'T opcja = Nic /// Wynik, jeśli wyjątek został wyrzucony. pozwalać zmienny ext : Wyjątek opcja = Nic pozwalać Syncroot = nowy Obiekt() /// obiekt impulsowy używany do oczekiwania, aż wynik będzie gotowy. Upewnij się, że używa się, więc my /// nie muszę tworzyć obiektu, jeśli wynik jest wykonywany, zanim będzie potrzebny. pozwalać zmienny puls : ManualResetevent = zero pozwalać Upewnij się() = zamek Syncroot (zabawa () -> mecz puls z | zero -> puls  nowy ManualResetevent(FAŁSZ); |. _ -> () puls) /// OSTRZEŻENIE: Zadzwoń, gdy blokada na Syncroot zostanie już przetrzymywana. Pulsuje powiadomienie o oczekiwaniu. Bezpieczny, jeśli /// nazywane po &bdquo;pulse&rdquo; powstaje, ale przed wezwaniem Waitone. pozwalać powiadomienia() = Jeśli puls <> zero Następnie puls.Ustawić() |> ignorować pozwalać praca = nowy Wartość w tle() /// na runWorkerAsync (), uruchom określone funkcje i przechowuj wyniki. Wszystkie wyjątki muszą być /// uwięziony. Do praca.Wykonać pracę.Dodać( zabawa Args -> próbować wynik  Niektóre( F()) z mi -> ext  Niektóre mi zamek Syncroot ( zabawa () -> powiadomienia())) /// Rozpocznij natychmiast/ automatycznie. Do praca.RunworkerAsync() /// Zwraca wartość obliczeń, blokując, jeśli wynik nie jest jeszcze gotowy. członek T.Wartość = //, jeśli jest to dostępne, możemy go od razu zwrócić. mecz wynik z | Niektóre X -> X | Nic Kiedy ext.Issome -> wznosić (Opcja.Dostawać ext) | Nic -> pozwalać P = Upewnij się() // Sprawdź ponownie na wypadek, gdyby się zmieniło, gdy dostaliśmy obiekt oczekiwania. mecz wynik z | Niektóre X -> X | Nic -> // bez zamykania jest w porządku, ponieważ jeśli puls.Metoda set () jest wywoływana między tym, kiedy my // Sprawdzony &bdquo;wynik&rdquo; i zadzwoń do Waitone tutaj, Waitone powróci natychmiast. P.Waitone(1000000000) |> ignorować mecz wynik z | Niektóre X -> X | Nic -> Jeśli ext.Issome Następnie wznosić (Opcja.Dostawać ext) w przeciwnym razie Niepowodzenie &bdquo;Przyszłe obliczenia nie powiodły się." /// Zwraca true, jeśli obliczenia jest zakończone, fałsz, jeśli nie. członek T.Jest gotowy = mecz wynik z | Niektóre X -> PRAWDA | Nic Kiedy Opcja.Issome ext -> PRAWDA | Nic -> FAŁSZ 

System przestrzeni nazw

System przestrzeni nazw.ComponentModel

System przestrzeni nazw.Gwintowanie

Wiele elementów
Typ przyszłość =
NOWOŚĆ: F: (jednostka -> 't) -> przyszłość
Członek Iscomplete: Bool
Wartość członka: &bdquo;T

Pełna nazwa: Skrypt.Przyszły

Wykonuje obliczenia w pracownikach w tle i synchronizuje się w związku.
Obliczenia są rozpoczynające się natychmiast, a wywołanie &bdquo;wartości&rdquo; blokuje, aż wynik będzie gotowy.

Val F: (jednostka -> 't)

Typ jednostka = jednostka

Pełna nazwa: Microsoft.Fsharp.Rdzeń.jednostka

WAL MOTABLATE Result: &bdquo;T Opcja

Wynik obliczeń na normalnym wyjściu.

Typ 't opcja = opcja

Pełna nazwa: Microsoft.Fsharp.Rdzeń.opcja

Opcja sprawy związkowej.Brak: opcja

VAL MUTABLE EXT: Opcja wyjątku

Wynik, jeśli wyjątek został wyrzucony.

Wiele elementów
Typ wyjątek =
NOWOŚĆ: Jednostka -> wyjątek + 2 przeciążenia
Dane członka: identyczność
Członek getBaseexception: jednostka -> wyjątek
Członek getObjectData: Info: Serializacjainfo * kontekst: streamingContext -> jednostka
Członek GetType: jednostka -> Typ
Member Selplink: String z get, zestaw
członek innoxception: wyjątek
Komunikat członka: ciąg
Źródło członka: ciąg z get, zestaw
członek StackTrace: String
.

Pełna nazwa: System.Wyjątek

--------------------
Wyjątek (): jednostka
Wyjątek (komunikat: ciąg): jednostka
Wyjątek (komunikat: ciąg, InnoxException: EXN): jednostka

Val Syncroot: Obiekt

Wiele elementów
Typ obiekt =
nowy: jednostka -> obj
Członek jest równy: OBJ: OBJ -> bool
Członek Gethashcode: jednostka -> int
Członek GetType: jednostka -> Typ
TOSTRING: Jednostka -> String
Statyczny członek to: obja: obj * objb: obj -> bool
Statyczne odniesienia członków: obja: obj * objb: obj -> bool

Pełna nazwa: System.Obiekt

WAL MOTABLAble Pulse: ManualReseTent

Obiekt pulsacyjny zwykł czekać, aż wynik będzie gotowy. Upewnij się, że używa się, więc my
Nie muszę tworzyć obiektu, jeśli wynik jest wykonywany, zanim będzie potrzebny.

Wiele elementów
Typ ManualReseTevent =
Dziedzicz EventWaithandle
NOWOŚĆ: InitialState: Bool -> ManualReseTevent

Pełna nazwa: System.Gwintowanie.ManualResetevent

--------------------
ManualReseTevent (InitialState: bool): jednostka

val Upewnij się: (jednostka -> manualReseTevent)

VAL Lock: LockObject: 'Lock -> Action: (jednostka ->' t) -> 't (wymaga typu odniesienia)

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Operatorzy.zamek

Val NotifyWaiteers: (jednostka -> jednostka)

OSTRZEŻENIE: Zadzwoń, gdy blokada na Syncroot zostanie już przechowywana. Pulsuje powiadomienie o oczekiwaniu. Bezpieczny, jeśli
nazywany po &bdquo;Pulse&rdquo;, ale zanim Waitone zostanie wezwany.

EventWaithandle.Set (): bool

val ignor: wartość: &bdquo;t -> jednostka

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Operatorzy.ignorować

Val Work: Worth Worker

Wiele elementów
Wpisz TimeWorker =
Komponent dziedziczny
NOWOŚĆ: jednostka -> Wartość w tle
Członek anulowanie się: jednostka -> jednostka
Odwołanie członków Pobiega: bool
Członek Isbusy: Bool
Raport członkowskiProgress: ProcentProgress: INT -> Jednostka + 1 Przeciążenie
Członek RunworkerAsync: jednostka -> jednostka + 1 przeciążenie
Pracownik członkowski ReportSprogress: Bool with get, set
Pracownicy członkowskie
wydarzenie Dowork: Doworkeventhandler
Event ProgressChanged: ProgressChangedEventHandler
.

Pełna nazwa: System.ComponentModel.Wartość w tle

Współczynnik zdarzeń.Dowork: Ievent

Członek IOBServable.Dodaj: zwrot oddzwonienia 🙁 't -> jednostka) -> Jednostka

Val Args: Doworkeventargs

Opcja sprawy związkowej.Niektóre: wartość: 't -> opcja

Val E: EXN

Wartość w tle.RunworkerAsync (): jednostka
Wartość w tle.RunworkerAsync (argument: OBJ): jednostka

Val T: przyszłość

Przyszłość członka.Wartość: 't

Pełna nazwa: Skrypt.Przyszłość '1.Wartość

Na działających pracownik () uruchom określone funkcje i przechowuj wyniki. Wszystkie wyjątki muszą być
uwięziony.
Rozpocznij natychmiast / automatycznie.
Zwraca wartość obliczeń, blokując, jeśli wynik nie jest jeszcze gotowy.

Opcja właściwości.Issome: Bool

Val Raise: Exn: wyjątek -> 't

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Operatorzy.wznosić

val get: opcja: 't opcja ->' t

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Opcja.Dostawać

Val P: ManualResetevent

Waithandle.Waitone (): bool
Waithandle.Waitone (limit czasu: Timespan): bool
Waithandle.Waitone (MilisecondStimeout: int): bool
Waithandle.WaitOne (Timeout: Timespan, ExitContext: bool): bool
Waithandle.Waitone (MilisecondStimeout: int, ExitContext: bool): bool

val nieważny: komunikat: String -> 't

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Operatorzy.Niepowodzenie

Przyszłość członka.IsComplete: Bool

Pełna nazwa: Skrypt.Przyszłość '1.Jest gotowy

Zwraca prawdziwie, jeśli obliczenia jest zakończone, fałsz, jeśli nie.

val issome: opcja: &bdquo;T opcja -> bool

Pełna nazwa: Microsoft.Fsharp.Rdzeń.Opcja.Issome

Kopiuj link Kopiuj źródło Raw Widok test testowy Nowa wersja

Więcej informacji

Budowanie funkcjonalne .Aplikacje netto: Przewodnik po wyborze między F# vs C#

Wydajność jest wszystkim w świecie rozwoju aplikacji. Deweloperzy i organizacje, które mogą szybciej wprowadzać produkty i zapewnić szybsze odświeżenia, zawsze będą mieli przewagę nad konkurencją.

Więc wszyscy zawsze szukają sposobów na skrócenie czasu rozwoju, czasu spędzonego na debugowaniu i testowaniu oraz pchanie gotowych wydań do klientów.

Programowanie funkcjonalne było powszechnie użyteczne dziesięciolecia, ale szybko straciło podstawę do obiektowych języków programowania, które wkrótce stały się de facto standardem.

Powiązane treści sponsorowane

Powiązany sponsor

Kod, wdrażanie i skalowanie Java po drodze.
Microsoft Azure obsługuje obciążenie obciążeniem z obfitymi wyborami, niezależnie od tego, czy pracujesz nad aplikacją Java, serwerem aplikacji czy frameworkiem. Ucz się więcej.

Ale w ostatnich latach nastąpiło odrodzenie zainteresowania programowaniem funkcjonalnym jako sposobem na poprawę wydajności rozwoju i budowanie bardziej stabilnych i solidnych aplikacji.

C# i F# to języki z rosnącymi bazami użytkowników, które podchodzą do programowania funkcjonalnego na zasadniczo różne sposoby: C# jako dodatek do jego nieodłącznego paradygmatu i f# jako głównego paradygmatu.

W tym artykule bada, który z tych języków wykonuje najlepszą robotę dla programistów, którzy chcą wprowadzić programowanie funkcjonalne dla swoich zespołów i projektów.

Debata na temat programowania funkcjonalnego kontra obiektowego

Aby zrozumieć debatę, musimy zacząć od nieco wyższego poziomu z różnicą między paradygmatami programowania imperatywnego i deklaratywnego.

• Programowanie imperatywne: Podejście do programowania oparte na procesie, w którym programiści określają, jak osiągnąć wyniki krok po kroku. Programowanie imperatywne koncentruje się na zmianach stanu i stanu. Obiektowe języki programowania, takie jak Java i C ++, ogólnie podążają za paradygmatem imperatywnym.
• Deklaratywne programowanie: Podejście programowania zorientowane na wyniki, w którym programiści określają rodzaje pożądanych wyników. Programowanie deklaratywne jest bezpaństwowe i zamówienie wykonania agnostyczne. Funkcjonalne języki programowania, takie jak Lisp, Python, Haskell i F# postępuj zgodnie z deklaratywnym paradygmatem programowania.

Ale jest to nadmierne uproszczenie, aby starannie podzielić wszystkie istniejące języki programowania na te kategorie, ponieważ kilka języków oferuje aspekty każdego. Są to języki hybrydowe lub wieloparadygmowe.

Na przykład, mimo że Java i C ++ tradycyjnie mieszczą się w klasyfikacji imperatywnej, mają również aspekty funkcjonalne. To samo dotyczy C#. Podobnie, chociaż F# jest uważane za język funkcjonalny, ma również możliwości imperatywne.

Spójrz na listę dziesięciu najważniejszych języków, które używają twórcy. Zobaczysz, że obejmują one głównie języki hybrydowe, a niektórzy koncentrują się na imperatywach, a inne bardziej dominują.

JavaScript, który od dekady zajmował pierwsze miejsce w tej ankiecie, jest językiem multi-paradigm, oferującym zarówno funkcje imperatywne, obiektowe, jak i funkcje funkcjonalne.

Biorąc pod uwagę zakres adopcji, pomocne jest rozważenie różnych korzyści, które przedstawia każdy paradygmat i różne przypadki użycia, w których każdy wyróżnia się.

Programowanie imperatywne: korzyści i przypadki użycia

Jednym z głównych korzyści paradygmatu imperatywnego jest to, że kod pisany, używając go, jest ogólnie łatwo zrozumiany i może być łatwy do odczytania. Ponadto, biorąc pod uwagę skrupulatne opisy przepływu pracy, których wymaga programowanie imperatywne, nawet początkujący programiści łatwo jest śledzić.

Ale poziom programowania detalicznego wymaga również wad z wadami. Na przykład w bardziej złożonych aplikacjach kod może szybko zostać wzdęty. Wraz ze wzrostem wielkości kodu łatwość czytania i rozumienia równie szybko spada.

Ponadto, wraz z rozwojem kodu, zwiększa się potencjał błędów i błędów. W ten sposób programiści pracujący z językami imperatywnymi często spędzają dużo czasu na debugowaniu i testowaniu, opóźniając wydania produktów.

Niemniej jednak programowanie imperatywne pozostaje niezwykle popularne i ma szeroki zakres przypadków użycia. Tradycyjne aplikacje do programowania imperatywnego obejmują:

• Hipertekst i hipermedia
• Object Systemy zarządzania bazą danych (ODBM)
• Systemy klientów-serwerów
• Systemy w czasie rzeczywistym
• Sztuczna inteligencja, uczenie maszynowe i sieci neuronowe
• Automatyzacja

Programowanie funkcjonalne: korzyści i przypadki użycia

Korzyści z programowania funkcjonalnego lądują bardziej po stronie wydajności równania. Kod funkcjonalny, choć mniej łatwy do odczytania i zrozumienia na pierwszy rzut oka, zwykle jest bliżej wolnej od błędów (i.mi., Brak skutków ubocznych dla zmian stanu), skracanie czasu programisty spędzonego na debugowaniu i testowaniu.

Mniej błędów nadaje się również do bezpieczniejszych aplikacji, ograniczając powierzchnię ataku dla cyberprzestępców w celu zmniejszenia szans na ataki ransomware, złośliwe oprogramowanie lub zastrzyki SQL.

Programowanie funkcjonalne jest również lepsze zarówno przy równoległym przetwarzaniu, jak i leniwej ocenie. Ponadto kod funkcjonalny jest bardziej modułowy i wielokrotnego użytku, zmniejszając potrzebę zbędnego kodu. Mniejszy zestaw kodów jest łatwiejszy w utrzymaniu i może być wyższy. Jednak kod funkcjonalny może być intensywny pamięć, eliminując wszelkie korzyści prędkości z zmniejszonej wielkości kodu i faktycznie prowadząc do zmniejszonej ogólnej wydajności.

Programowanie funkcjonalne jest szczególnie popularne wśród naukowców akademickich i danych, ponieważ jest skuteczne w radzeniu sobie z manipulacją dużymi zestawami danych.

Biorąc pod uwagę jego koncentrację na równoległym przetwarzaniu i niezmienności, programowanie funkcjonalne jest szczególnie przydatne dla:

• Data Science
• Aplikacje arkusza kalkulacyjnego
• Zastosowania finansowe i ryzyka
• Przetwarzanie wsadowe

Programowanie funkcjonalne: C# vs f#

C# i F# to języki, które zyskują na popularności w ostatnich latach. Chociaż oba są to multi-paradygmaty, ich główne skupienie różni się, a C# opiera się na zasadach zorientowanych na obiekty, i f# polegającym na zasadach funkcjonalnych. Ale jedno przewyższa drugie, jeśli chodzi o programowanie funkcjonalne?

Co to jest c#i kto go używa?

C# to multi-paradigm, język obiektowy wydany po raz pierwszy przez Microsoft około 20 lat temu. Jak widać z powyższych statystyk użytkowania, był to ósmy najpopularniejszy język wśród programistów w 2022. Ma również wysokie wyniki satysfakcji, a dwie trzecie użytkowników C# twierdzi, że uwielbiają go używać.

C# znajduje wiele zastosowań w opracowywaniu usług internetowych i chmurowych, a także w tworzeniu gier. Firmy od Microsoft po TrustPilot po StackoverFlow tworzą aplikacje i usługi z C#.

Programowanie funkcjonalne w C#

Chociaż C# jest przede wszystkim zorientowane na obiekty i zmienne/stanowe, ma możliwości funkcjonalne. Oto kilka sposobów na wdrożenie paradygmatu funkcjonalnego w C#.

Stwórz niezmienność

Ponieważ typy danych w C# są z natury zmienne, gdy chcesz używać zasad programowania funkcjonalnego, musisz stworzyć niezmienność. I jest to bardziej skomplikowane niż po prostu poleganie na niezmiennych typach danych w F#. W szczególności, aby utworzyć niezmienne typy w C#, musisz wykonać Typ tylko odczyt, usunąć właściwości setter, użyć konstruktora, aby zapewnić parametry, a następnie utworzyć nową instancję za każdym razem, gdy potrzebna jest zmiana stanu, zamiast mutować istniejącą instancję.

Użyj wyrażeń LINQ i Lambda

Microsoft zbudował framework LINQ (Language Integrated Query), aby wprowadzić funkcjonalne funkcje programowania do C#. LINQ zapewnia funkcje do działania na listach lub sekwencjach, w tym mapowanie (wybierz), sortowanie (OrderBy) i filtrowanie (gdzie). Każdy z tych wyrażeń ma funkcje dla argumentów. Wyrażenia tworzą nowe instancje sekwencji, a nie mutowanie istniejącej sekwencji. LINQ jest szczególnie przydatny do zapytania o zestawy danych, czy to tabele SQL, dane XML, czy inne źródła.

LINQ pozwala również na użycie wyrażeń Lambda, które są zasadniczo funkcjami anonimowymi. Funkcje anonimowe są kluczowym aspektem programowania funkcjonalnego. Wyrażenia Lambda mogą działać jako argumenty dla innych funkcji w kodzie, tworząc funkcje wyższego rzędu, kolejną wspólną cechą programowania funkcjonalnego.

Użyj łańcuchów metod

Powszechnie używaną cechą F# jest operator rurociągu, który przekazuje wynik jednej funkcji do innej funkcji. Ruroiping nie jest wbudowany w C, ale programiści mogą naśladować rurociągi w niektórych sytuacjach za pomocą łańcuchów metod lub płynnych interfejsów. Można to wykonać za pomocą funkcji StringBuilder w C#.

Łańcuchy metod pozwalają również powtórzyć inną wspólną funkcję programowania funkcjonalnego, currying. Currying pozwala funkcji z wieloma argumentami na otrzymywanie tych argumentów w różnych momentach. Zasadniczo w programowaniu funkcjonalnym, jeśli funkcja nie odbiera wszystkich potrzebnych danych wejściowych, zwraca nową funkcję z brakującymi wejściami jako argumenty.

W C#implementujesz currying z łańcuchami metod, aby rozłożyć wielofunkcyjny argument w zagnieżdżoną sekwencję kilku funkcji pojedynczych argumentów. Nie jest to jednak tak schludne ani tak wydajne jak w F#.

To tylko niektóre ze sposobów, w jakie wykwalifikowani programiści mogą stosować zasady programowania funkcjonalnego w C#. I chociaż mogą wymagać więcej wysiłku niż zwykłe użycie f#, dla tych programistów, którzy chcą wszystkich innych funkcji, które C# ma do zaoferowania, są realną alternatywą.

Co to jest f#i kto go używa?

Początkowo wydany przez Microsoft dla platformy Windows w 2005 roku, F# jest głównie funkcjonalnym językiem programowania. Rozszerzył się na platformy Linux i MacOS w 2010 roku, a następnie JavaScript w 2013 roku. Ponadto w 2013 r.

Od jego powstania społeczność F# stale rosła, choć powoli. Obejmuje teraz grupę GitHub, a także wiele różnych projektów społecznościowych, od transpiterów JavaScript (bajka) po menedżerów opakowań (PAKET) po biblioteki rozwoju internetowego (uprzejmy) i nie tylko.

Mimo swojego wieku F# nadal ma znaczną przestrzeń do adopcji. Ogólne statystyki użytkowania są nieco trudne do zdobycia, ale ankieta 2021 przeprowadzona przez palety ponad 30000 programistów wskazało, że tylko 1% ostatnio korzystało z F# lub planowało to zrobić w najbliższej przyszłości. Dla porównania, 21% niedawno wykorzystało C#, a 4% planowało go wkrótce użyć. A F# ma nieco niższą ocenę satysfakcji niż C#, chociaż ponad 60% programistów twierdzi, że uwielbia go używać.

Obecnie jest mniej niż 100 firm, o których wiadomo, że używa F# w produkcji, chociaż zawierają one niektóre znane nazwiska, takie jak Walmart i Huddle.

Niektórzy programiści używają F# jako uzupełnienia do C#, zamiast polegać na funkcjonalnych możliwościach, które istnieją natywnie w C#. Ponieważ oba kompilują .Języki pośrednie netto (IL), możliwe jest użycie obu w tym samym projekcie.

Który język ma przewagę programowania funkcjonalnego?

Wygląda na to, że powinno to być bardzo proste pytanie: F# jest najpierw funkcjonalne, podczas gdy C# jest najpierw konieczne, więc krawędź trafia do F#. A na najwyższym poziomie to stwierdzenie jest prawdziwe. Ale opracowanie aplikacji, podobnie jak życie, jest rzadko proste do uogólnionego zastosowania prawd na wysokim poziomie.

Lepszym pytaniem jest, który język jest odpowiedni dla Ciebie, Twojego zespołu i projektów, nad którymi w tej chwili pracujesz. I to jest o wiele bardziej złożone pytanie, na które należy odpowiedzieć.

Wybór odpowiedniego języka do programowania funkcjonalnego

Wybierając między C# i F# dla twoich potrzeb programowania funkcjonalnego, istnieje kilka rozważań, które powinny uwzględniać twoją decyzję:

• Jakie są potrzeby projektu? Konkretne zestawy funkcji aplikacji mogą zająć długą drogę w procesie decyzyjnym. Na przykład, jeśli najważniejsze funkcje aplikacji obracają się wokół elementów interfejsu użytkownika, z niewielką manipulacją danych, możesz skoncentrować się na C#. Ale jeśli Twoja aplikacja jest intensywna danych, a elementy interfejsu użytkownika są mniej ważne, prawdopodobnie pochylisz się w kierunku F#.
• Jaki jest twój poziom komfortu z każdym językiem? Jeśli Twoja aplikacja skorzysta z programowania funkcjonalnego, ale nie&rsquo;T Doświadczenie z C#, aby łatwo poradzić sobie z manipulacjami potrzebnymi do tworzenia niezmiennych typów i przełożenia z deklaracji na wyrażenia, a następnie należy rozważyć f#.
• Jak Twój zespół poradzi sobie z różnymi językami? Pracując z zespołem programistów, musisz rozważyć zestawy umiejętności i doświadczenie każdego członka zespołu. Możesz mieć jednego bardzo wykwalifikowanego programisty F#, ale inne z niewielką ekspozycją na f#. Może to prowadzić do trudności dla członków zespołu w pracy z kodem napisanym przez innych programistów.
• To najlepsze podejście wielojęzyczne? Czy Twój zespół programistów jest wystarczająco wykwalifikowany, aby zarówno C#, jak i F# współpracowali w tym samym projekcie? Czy istnieją powody, dla których jeden z tych języków nie ma&rsquo;T Wystarczająco zaspokajają wszystkie potrzeby aplikacji? Ale zastanów się dokładnie przed przyjęciem tego podejścia - powinieneś to zrobić tylko wtedy, gdy jest ono bardziej wydajne i bardziej skuteczne niż używanie dowolnego języka osobno.

Wniosek

Gdy projekt programistyczny wymaga programowania funkcjonalnego, zespół programistów dostępnych jest wiele opcji, od języków czysto funkcjonalnych po języki multi-paradigm, takie jak C# i F#. Dokonanie najlepszego wyboru spośród dobrych konkurencyjnych opcji nie zawsze jest proste, ale czas zainwestowany w podjęcie tej decyzji zostanie nagrodzony lepszą wydajnością rozwoju i produktami lepszej klasy.