Αυτό βοηθά στην ολοκλήρωση της εικόνας για τα σενάρια τεμαχισμού με συστοιχίες 3D και 4D.

Προεπισκόπηση: αντίστροφοι δείκτες

Η Microsoft εισάγει επίσης τη δυνατότητα χρήσης αντίστροφων ευρετηρίων, οι οποίοι μπορούν να χρησιμοποιηθούν με φέτες, ως προεπισκόπηση στο F# 5. Για να το χρησιμοποιήσετε, απλά τοποθετήστε προεπισκόπηση Στο αρχείο του έργου σας.

Αφήστε το XS = [1..10] // Λήψη στοιχείου 1 από το τέλος: xs.[^1] // Παλαιός τρόπος για να πάρετε τα δύο τελευταία στοιχεία αφήστε το LastTwoooldStyle = XS.[(XS.Μήκος-2)..] // Νέος τρόπος για να πάρετε τα δύο τελευταία στοιχεία αφήστε το lastTwoneWStyle = xs.[^1..] lastTwoooldStyle = lastTwOneWStyle // true 

Μπορείτε επίσης να ορίσετε τα δικά σας μέλη μέσω μιας επέκτασης τύπου F# για να αυξήσετε αυτούς τους τύπους για να υποστηρίξετε το F# Slicing and Reverse Indexes. Το ακόλουθο παράδειγμα το κάνει με τον τύπο Span:

Ανοίξτε τον τύπο συστήματος με το μέλος SP.GetSlice (startidx, endidx) = ας S = defaultArg startIdx 0 ας e = defaultarg endidx sp.Μήκος sp.Φέτα (s, e - s) μέλος SP.GetReverseIndex (_, offset: int) = sp.Μήκος - Offset Let SP = [| 1; 2; 3; 4; 5 |].Asspan () sp.[..^2] // [| 1; 2; 3 |] 

F# Οι εγγενείς τύποι έχουν ενσωματωμένα ευρετήρια ευρετήρια. Σε μια μελλοντική κυκλοφορία του F#, θα υποστηρίξουμε επίσης το Full Interop με το σύστημα.Ευρετήριο και σύστημα.Εύρος, σε αυτό το σημείο, το χαρακτηριστικό δεν θα είναι πλέον σε προεπισκόπηση.

Βελτιωμένες προσφορές κώδικα

Οι προσφορές κώδικα F# είναι μια δυνατότητα μεταπρογραμματισμού που σας επιτρέπει να χειριστείτε τη δομή του κώδικα F# και να την αξιολογήσετε σε ένα περιβάλλον της επιλογής σας. Αυτή η δυνατότητα είναι απαραίτητη για τη χρήση του F# ως μοντέλου γλώσσας κατασκευής για εργασίες μηχανικής μάθησης, όπου το μοντέλο AI μπορεί να λειτουργεί με διαφορετικό υλικό, όπως GPU. Ένα κρίσιμο κομμάτι που λείπει σε αυτό το παζλ ήταν η ικανότητα να αντιπροσωπεύει πιστά τις πληροφορίες περιορισμού τύπου F#, όπως αυτές που χρησιμοποιούνται στη γενική αριθμητική, στην προσφορά F# έτσι ώστε ένας αξιολογητής να μπορεί να γνωρίζει αυτούς τους περιορισμούς στο περιβάλλον που αξιολογεί.

Ξεκινώντας με το F# 5, οι περιορισμοί διατηρούνται τώρα σε προσφορές κώδικα, ξεκλειδώνοντας τη δυνατότητα ορισμένων βιβλιοθηκών όπως το Diffsharp για να χρησιμοποιήσει αυτό το τμήμα του συστήματος F# προς όφελός του. Ένας απλός τρόπος για να αποδείξετε ότι αυτός είναι ο ακόλουθος κωδικός:

Ανοίξτε το FSHARP.Λινά.RuntimeHelpers αφήστε το eval q = leafexpressionConverter .Αξιολογήστε το q let inline negate x = -x // Βασικά, το 'negate' έχει // την ακόλουθη υπογραφή: // // // // val inline nep: // x: ^a -> ^a // Όταν ^a: // (στατικό μέλος (~ -): ^a -> ^a) // . |> Αξιολόγηση 

Η χρήση ενός αριθμητικού χειριστή υποδηλώνει έναν περιορισμό τύπου έτσι ώστε όλοι οι τύποι που πέρασαν για να αρνηθούν πρέπει να υποστηρίξουν το ? χειριστής. Αυτός ο κωδικός αποτυγχάνει κατά το χρόνο εκτέλεσης, επειδή η προσφορά κώδικα δεν διατηρεί αυτές τις πληροφορίες περιορισμού, οπότε η αξιολόγηση του ρίχνει μια εξαίρεση.

Οι παραπομπές κώδικα είναι το θεμέλιο για κάποια ακόμη εργασία R & D-Heavy που γίνεται για να χρησιμοποιηθεί το F# ως γλώσσα για τη δημιουργία μοντέλων AI και έτσι η δυνατότητα διατήρησης των πληροφοριών περιορισμού τύπου σε αυτά βοηθά να γίνει μια συναρπαστική γλώσσα για τους προγραμματιστές σε αυτό το χώρο που αναζητούν λίγο περισσότερη ασφάλεια τύπου στη ζωή τους.

Το F# 5 έχει υπέροχα θεμελιώδη στοιχεία

Το F# 5 μπορεί να είναι για να γίνει η διαδραστικότητα και ο αναλυτικός προγραμματισμός καλύτερος, αλλά στον πυρήνα του, το F# 5 εξακολουθεί να κάνει την καθημερινή κωδικοποίηση στο F# a Joy. Το F# 5 περιλαμβάνει πολλά νέα χαρακτηριστικά που μπορούν να απολαύσουν τόσο οι προγραμματιστές εφαρμογών όσο και οι συγγραφείς βιβλιοθήκης.

Υποστήριξη για το όνομα

Πρώτα επάνω είναι ένα χαρακτηριστικό που οι προγραμματιστές C# έχουν έρθει να αγαπήσουν: όνομα . Το όνομα του χειριστή παίρνει ένα σύμβολο F# ως είσοδο και παράγει μια συμβολοσειρά σε χρονικό διάστημα που αντιπροσωπεύει αυτό το σύμβολο. Υποστηρίζει σχεδόν όλες τις κατασκευές F#. Το όνομα του χειριστή χρησιμοποιείται συχνά για τη διαγνωστική καταγραφή σε μια τρέχουσα εφαρμογή.

#r "Nuget: FSHARP.SystemTextJson "Ανοιχτό σύστημα.Κείμενο.Σύστημα ανοικτού JSON.Κείμενο.Json.Ανοιχτό σύστημα σειριοποίησης.Χρόνος εκτέλεσης.Μονάδα μεταγλωσσών M = Έστω F X = Όνομα x printfn "%s" (m.f 12) printfn "%s" (όνομα M) printfn "%s" (όνομα of m m.στ) /// απλοποιημένη έκδοση του τύπου API του EventStore RecordEventEvent = < EventType: string Data: byte[] >/// Τύπος σκυροδέματος μου: Πληκτρολογήστε myEvent = | Adata του int | BDATA του String // Χρησιμοποιήστε το 'Nameof' αντί για το String Literal in the Match Expression Let Deserialize (E: RecordEvent): MyEvent = Match E.Eventtype με | Όνομα του Adata -> JsonSerializer.Αποταμιεύστε e.Δεδομένα |> adata | Όνομα του Bdata -> jSonserializer.Αποταμιεύστε e.Δεδομένα |> bdata | t -> failwithf "Μη έγκυρο eventtype: %s" t 

Παρεμβολές χορδές

Το επόμενο είναι ένα χαρακτηριστικό που φαίνεται σε γλώσσες όπως το C# και το JavaScript: παρεμβολές χορδές. Οι παρεμβολές χορδές σας επιτρέπουν να δημιουργήσετε παρεμβολές ή τρύπες σε μια συμβολοσειρά που μπορείτε να συμπληρώσετε με οποιαδήποτε έκφραση F#. F# παρεμβολές χορδές Υποστήριξη Τυποποιημένες παρεμβολές συνώνυμες με την ίδια μορφή καθορίζει σε μορφές sprintf και printf strings. F# παρεμβολές χορδές υποστηρίζουν επίσης τις χορδές τριπλών προδιαγραφών. Ακριβώς όπως στο C#, όλα τα σύμβολα σε μια παρεμβολή F# είναι πλωτά, ικανά να μετονομαστούν και ούτω καθεξής.

// BASIC παρεμβαλλόμενη συμβολοσειρά LET NAME = "PHILLIP" LET AGE = 29 LET message = $ "Όνομα:, Ηλικία:" // typed Interpolation // ' %s' απαιτεί η παρεμβολή // "" "Όνομα": "", "Ηλικία": "" 

Επιπλέον, μπορείτε να γράψετε πολλαπλές εκφράσεις μέσα σε παρεμβαλλόμενες χορδές, παράγοντας διαφορετική τιμή για την παρεμβαλλόμενη έκφραση που βασίζεται σε μια είσοδο στη λειτουργία. Πρόκειται για μια πιο εξειδικευμένη χρήση του χαρακτηριστικού, αλλά επειδή οποιαδήποτε παρεμβολή μπορεί να είναι μια έγκυρη έκφραση F#, επιτρέπει μεγάλη ευελιξία.

Δηλώσεις ανοιχτού τύπου

Το F# σας επέτρεψε πάντα να ανοίξετε ένα χώρο ονομάτων ή μια ενότητα για να εκθέσετε τις δημόσιες κατασκευές της. Τώρα, με το F# 5, μπορείτε να ανοίξετε οποιοδήποτε τύπο για να εκθέσετε στατικά κατασκευάσματα όπως στατικές μεθόδους, στατικά πεδία, στατικές ιδιότητες και ούτω καθεξής. F# Ένωση και αρχεία μπορούν επίσης να ανοίξουν. Μπορείτε επίσης να ανοίξετε έναν γενικό τύπο σε μια συγκεκριμένη εμφάνιση τύπου.

σύστημα ανοικτού τύπου.MATH LET X = MIN (1.0, 2.0) Ενότητα M = Τύπος du = a | B | C Αφήστε κάποια MOTHERFUCTION X = X + 1 // Ανοίξτε μόνο τον τύπο μέσα στην μονάδα Open Type M.Du printfn "%a" α 

Βελτιωμένες εκφράσεις υπολογισμού

Οι εκφράσεις υπολογισμού είναι ένα πολύ αγαπημένο σύνολο χαρακτηριστικών που επιτρέπουν στους συγγραφείς βιβλιοθήκης να γράφουν εκφραστικό κωδικό. Για όσους έμπαιναν στην θεωρία κατηγοριών, είναι επίσης ο επίσημος τρόπος για να γράψετε μοναδικούς και μονοειδείς υπολογισμούς. Το F# 5 επεκτείνει τις εκφράσεις υπολογισμού με δύο νέα χαρακτηριστικά:

• Εφαρμοστικά έντυπα για εκφράσεις υπολογισμού μέσω του LET. και! λέξεις -κλειδιά
• Σωστή υποστήριξη για υπερφόρτωση προσαρμοσμένων λειτουργιών

“Εφαρμοστικά έντυπα για εκφράσεις υπολογισμού” είναι λίγο μπουκιά. Θα αποφύγω την κατάδυση στη θεωρία των κατηγοριών και αντ 'αυτού θα δουλέψω με ένα παράδειγμα:

// Πρώτον, ορίστε ένα αποτέλεσμα λειτουργίας "zip" module = let zip x1 x2 = match x1, x2 με | Εντάξει x1res, ok x2res -> ok (x1res, x2res) Σφάλμα E, _ -> Σφάλμα E | _, Σφάλμα e -> σφάλμα e // Στη συνέχεια, καθορίστε έναν οικοδόμο με "mergesources" και "bindreturn" type resultBuilder () = μέλος _.Mergesources (T1: Αποτέλεσμα, T2: Αποτέλεσμα) = αποτέλεσμα.Zip T1 T2 Μέλος _.Bindreturn (x: αποτέλεσμα, f) = αποτέλεσμα.Χάρτης F X LET result = resultBuilder () Αφήστε το r1 r2 r3 = // και εδώ είναι το applicative μας! Έστω res1: αποτέλεσμα = αποτέλεσμα < let! a = r1 and! b = r2 and! c = r3 return a + b - c >Match Res1 με | Ok x -> printfn " %s είναι: %d" (όνομα res1) x | Σφάλμα e -> printfn " %s είναι: %s" (όνομα res1) e 

Πριν από το F# 5, καθένα από αυτά και! Οι λέξεις -κλειδιά θα είχαν αφήσει! λέξεις -κλειδιά. Το και! Η λέξη -κλειδί διαφέρει από το ότι η έκφραση που ακολουθεί πρέπει να είναι 100% ανεξάρτητη. Δεν μπορεί να εξαρτάται από το αποτέλεσμα μιας προηγούμενης αφαίρεσης! -δεσμευμένη αξία. Αυτό σημαίνει ότι ο κώδικας όπως ο παρακάτω αποτυγχάνει να μεταγλωττίσει:

Έστω res1: αποτέλεσμα = αποτέλεσμα < let! a = r1 and! b = r2 a // try to pass 'a' and! c = r3 b // try to pass 'b' return a + b - c >

Λοιπόν, γιατί θα κάναμε αυτόν τον κώδικα να μην καταρτίσει? Μερικοί λόγοι. Πρώτον, επιβάλλει υπολογιστική ανεξαρτησία κατά τη μεταγλώττιση χρόνου. Δεύτερον, αγοράζει λίγη απόδοση κατά το χρόνο εκτέλεσης, επειδή επιτρέπει στον μεταγλωττιστή να δημιουργήσει το γράφημα κλήσεων στατικά. Τρίτον, επειδή κάθε υπολογισμός είναι ανεξάρτητος, μπορούν να εκτελεστούν παράλληλα με οποιοδήποτε περιβάλλον που τρέχουν. Τέλος, εάν αποτύχει ένας υπολογισμός, όπως στο προηγούμενο παράδειγμα όπου κάποιος μπορεί να επιστρέψει μια τιμή σφάλματος αντί για μια τιμή OK, το όλο θέμα δεν βραχυκυκλώνεται σε αυτή την αποτυχία. Εφαρμοστικά έντυπα “μαζεύω” Όλες οι τιμές που προκύπτουν και επιτρέπουν σε κάθε υπολογισμό να τρέξει πριν τελειώσει. Εάν επρόκειτο να αντικαταστήσετε το καθένα και! με ένα let! , Οποιοσδήποτε επέστρεψε ένα σφάλμα βραχυκυκλώματα από τη λειτουργία. Αυτή η διαφορετική συμπεριφορά επιτρέπει στους συγγραφείς και τους χρήστες της βιβλιοθήκης να επιλέξουν τη σωστή συμπεριφορά με βάση το σενάριό τους.

Εάν αυτό ακούγεται σαν να είναι λίγο βαριά, αυτό είναι εντάξει! Οι εφαρμοστικοί υπολογισμοί είναι ένα κομμάτι μιας προηγμένης έννοιας από την άποψη του συγγραφέα της βιβλιοθήκης, αλλά είναι ένα ισχυρό εργαλείο για αφαίρεση. Ως χρήστης τους, δεν χρειάζεται να γνωρίζετε όλα τα μέσα και τα outs για το πώς λειτουργούν. Μπορείτε απλά να γνωρίζετε ότι κάθε υπολογισμός σε μια έκφραση υπολογισμού είναι εγγυημένη να λειτουργεί ανεξάρτητα από τους άλλους.

Μια άλλη ενίσχυση των εκφράσεων υπολογισμού είναι η δυνατότητα να υποστηρίξουμε σωστά την υπερφόρτωση για προσαρμοσμένες λειτουργίες με το ίδιο όνομα λέξης -κλειδιού, υποστήριξη για προαιρετικά επιχειρήματα και υποστήριξη για το σύστημα.Επιχειρήματα Paramarray. Μια προσαρμοσμένη λειτουργία είναι ένας τρόπος για έναν συγγραφέα βιβλιοθήκης να καθορίσει μια ειδική λέξη -κλειδί που αντιπροσωπεύει το δικό του είδος λειτουργίας που μπορεί να συμβεί σε μια έκφραση υπολογισμού. Αυτή η λειτουργία χρησιμοποιείται πολύ σε πλαίσια όπως ο Κρόνος για να ορίσει ένα εκφραστικό DSL για την κατασκευή εφαρμογών ιστού. Ξεκινώντας με το F# 5, οι συντάκτες των εξαρτημάτων όπως ο Κρόνος μπορούν να υπερφορτώσουν τις προσαρμοσμένες λειτουργίες τους χωρίς προειδοποιήσεις, όπως φαίνεται στο Λίστα 1.

Λίστα 1: Οι εκφράσεις υπολογισμού μπορούν να υπερφορτωθούν προσαρμοσμένες λειτουργίες

πληκτρολογήστε το εισόδημα = | Κείμενο PlaceHolder: Επιλογή συμβολοσειράς | Κωδικός πρόσβασης του PlaceHolder: String Type Type InputOptions = < Label: string option Kind: InputKind Validators: (string ->Bool) Array> Πληκτρολογήστε εισόδους Builder () = μέλος t.Απόδοση (_) = < Label = None Kind = Text None Validators = [||] >[] Μέλος αυτό.Κείμενο (io,?σύμβολο σύμβασης) = < io with Kind = Text placeholder >[] Μέλος αυτό.Κωδικός πρόσβασης (io,?σύμβολο σύμβασης) = < io with Kind = Password placeholder >[] Μέλος αυτό.Ετικέτα (io, ετικέτα) = < io with Label = Some label >[] Μέλος αυτό.Επικυρωτές (io, [] επικυρωτές) = < io with Validators = validators >αφήστε το input = inputBuilder () αφήστε το όνομα = είσοδος < label "Name" text with_validators (String.IsNullOrWhiteSpace >> όχι)> Αφήστε το email = είσοδος < label "Email" text "Your email" with_validators (String.IsNullOrWhiteSpace >> όχι) (διασκέδαση -> s.Περιέχει "@")> Αφήστε τον κωδικό πρόσβασης = είσοδος < 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 ->μικρό.Μήκος> = 6)> 

Η σωστή υποστήριξη για υπερφόρτωση σε προσαρμοσμένες λειτουργίες αναπτύσσεται εξ ολοκλήρου από δύο συνεισφέροντες του F# F# Diego Esmerio και Ryan Riley.

Με εφαρμοστικά έντυπα για εκφράσεις υπολογισμού και δυνατότητα υπερφόρτωσης προσαρμοσμένων λειτουργιών, είμαστε ενθουσιασμένοι που βλέπουμε τι μπορούν να κάνουν οι συγγραφείς της βιβλιοθήκης F# στη συνέχεια.

Εφαρμογές διεπαφής σε διαφορετικές γενικές παραστάσεις

Ξεκινώντας με το F# 5, μπορείτε τώρα να εφαρμόσετε την ίδια διεπαφή σε διαφορετικές γενικές στιγμές. Αυτό το χαρακτηριστικό αναπτύχθηκε σε συνεργασία με τον Lukas Rieger, έναν συνεισφέροντα ανοιχτού κώδικα F#.

Τύπος IA = αφηρημένο μέλος Get: Μονάδα -> ?T Πληκτρολογήστε myClass () = διεπαφή IA με μέλος x.Get () = 1 διασύνδεση IA με μέλος x.Get () = "Γεια σας" ας MC = myClass () LET asint = mc:> ia altstring = mc:> ia asint.Λήψη () // 1 asstring.Λάβετε () // "Γεια σας" 

Περισσότερο .Καθαρές βελτιώσεις Interop

.Το NET είναι μια εξελισσόμενη πλατφόρμα, με νέες έννοιες που εισάγονται κάθε απελευθέρωση και επομένως, περισσότερες ευκαιρίες για να διαμορφωθούν. Διεπαφές στο .Το NET μπορεί τώρα να καθορίσει προεπιλεγμένες εφαρμογές για μεθόδους και ιδιότητες. Το F# 5 σάς επιτρέπει να καταναλώνετε απευθείας αυτές τις διεπαφές. Εξετάστε τον ακόλουθο κωδικό C#:

χρησιμοποιώντας το σύστημα. ονόματος χώρος < public interface MyDim < public int Z =>0; >> 

Αυτή η διεπαφή μπορεί να καταναλωθεί απευθείας στο F#:

Ανοίξτε το CSHARP // Δημιουργήστε μια έκφραση αντικειμένου για να εφαρμόσετε τη διεπαφή LET MD = < new MyDim >printfn $ "Dim από C#:" 

Μια άλλη ιδέα στο .Το καθαρό που παίρνει περισσότερη προσοχή είναι οι μηδενικοί τύποι αξίας (που ονομάζονται πρώην μηδενικοί τύποι). Αρχικά δημιουργήθηκε για να αντιπροσωπεύει καλύτερα τους τύπους δεδομένων SQL, είναι επίσης θεμελιώδεις για τις βασικές βιβλιοθήκες χειρισμού δεδομένων όπως η αφαίρεση πλαισίου δεδομένων στη Microsoft.Δεδομένα.Ανάλυση . Για να γίνει λίγο πιο εύκολο στο Interop με αυτές τις βιβλιοθήκες, εφαρμόζετε έναν νέο κανόνα κατευθυνόμενο από τον τύπο για τις μεθόδους κλήσης και την ανάθεση τιμών σε ιδιότητες που είναι ένας μηδενικός τύπος τιμής. Εξετάστε το ακόλουθο δείγμα χρησιμοποιώντας αυτό το πακέτο με οδηγία αναφοράς πακέτου:

#r "Nuget: Microsoft.Δεδομένα.Ανάλυση "Ανοίξτε το σύστημα Ανοίξτε τη Microsoft.Δεδομένα.Ανάλυση LETTIMES = "DateTimes".Parse ("2019/01/01") DateTimes DateTimes.Προσάρτημα (Ημερομηνία) // Το προηγούμενο είναι τώρα ισοδύναμο με: Let Date = DateTime.PARSE ("2019/01/01") Αφήστε τα δεδομένα = μηδενικά (ημερομηνία) DateTimes.Προσάρτημα (δεδομένα) 

Αυτά τα παραδείγματα χρησιμοποιούνται για να απαιτήσουν να κατασκευάσετε ρητά έναν τύπο μηδενικής τιμής με τον μηδενικό κατασκευαστή τύπου όπως δείχνει το παράδειγμα.

Καλύτερη απόδοση

Η ομάδα της Microsoft έχει περάσει το παρελθόν έτος βελτιώνοντας την απόδοση του F# από ​​την άποψη της απόδοσης και της απόδοσης εργαλείων σε IDE όπως το Visual Studio. Αυτές οι βελτιώσεις απόδοσης έχουν κυκλοφορήσει σταδιακά και όχι ως μέρος μιας μεγάλης απελευθέρωσης. Το άθροισμα αυτού του έργου που κορυφώνεται στο F# 5 μπορεί να κάνει τη διαφορά για τον καθημερινό F# προγραμματισμό. Για παράδειγμα, έχω συντάξει τον ίδιο κωδικό βάσης ? Το βασικό έργο στο FSHARPLUS, ένα έργο που υπογραμμίζει τον μεταγλωττιστή F# ? τρεις φορές. Μία φορά για το F# 5, μία φορά για το τελευταίο F# 4.7 με .Net Core και μία φορά για το τελευταίο F# 4.5 σε .Καθαρός πυρήνας, όπως φαίνεται στο Τραπέζι 1.

Τα αποτελέσματα Τραπέζι 1 προέρχονται από την εκτέλεση του Dotnet Build /CLP: Densformancesunnary από τη γραμμή εντολών και εξετάζοντας το συνολικό χρόνο που δαπανάται στην εργασία FSC, η οποία είναι ο μεταγλωττιστής F#. Τα αποτελέσματα ενδέχεται να διαφέρουν στον υπολογιστή σας ανάλογα με πράγματα όπως η προτεραιότητα της διαδικασίας ή η εργασία στο παρασκήνιο, αλλά θα πρέπει να δείτε περίπου τις ίδιες μειώσεις των χρόνων μεταγλωττισμού.

Η απόδοση IDE επηρεάζεται συνήθως από τη χρήση μνήμης, επειδή οι IDE, όπως το Visual Studio, φιλοξενούν έναν μεταγλωττιστή μέσα σε μια υπηρεσία γλωσσών ως μακροχρόνια διαδικασία. Όπως και με άλλες διαδικασίες διακομιστή, όσο λιγότερη μνήμη χρησιμοποιείτε, τόσο λιγότερο ο χρόνος GC δαπανά τον καθαρισμό της παλιάς μνήμης και όσο περισσότερο χρόνο μπορεί να δαπανηθεί επεξεργασία χρήσιμων πληροφοριών. Επικεντρώσαμε δύο σημαντικούς τομείς:

• Χρησιμοποιώντας αρχεία χαρτογράφησης μνήμης για να διαβάσετε τα μεταδεδομένα πίσω από τον μεταγλωττιστή
• Επαναπροσδιορισμός λειτουργιών που βρίσκουν σύμβολα σε μια λύση, όπως βρίσκουν όλες τις αναφορές και μετονομασία

Το αποτέλεσμα είναι σημαντικά λιγότερη χρήση μνήμης για μεγαλύτερες λύσεις όταν χρησιμοποιείτε χαρακτηριστικά IDE. Εικόνα 5 Δείχνει ένα παράδειγμα χρήσης μνήμης κατά την εκτέλεση αναφορών στον τύπο συμβολοσειράς σε ψεύτικο, ένα πολύ μεγάλο κώδικα ανοιχτού κώδικα, πριν από τις αλλαγές που κάναμε.

Αυτή η λειτουργία διαρκεί επίσης ένα λεπτό και 11 δευτερόλεπτα για να ολοκληρωθεί όταν εκτελείται για πρώτη φορά.

Με το F# 5 και τα ενημερωμένα εργαλεία F# για το Visual Studio, η ίδια λειτουργία διαρκεί 43 δευτερόλεπτα για να ολοκληρωθεί και χρησιμοποιεί πάνω από 500MB λιγότερη μνήμη, όπως φαίνεται στο Εικόνα 6.

Το παράδειγμα με τα αποτελέσματα που παρουσιάζονται στο Εικόνα 5 και Εικόνα 6 είναι ακραίο, αφού οι περισσότεροι προγραμματιστές δεν αναζητούν χρήσεις ενός τύπου βάσης όπως η συμβολοσειρά σε ένα πολύ μεγάλο κώδικα, αλλά δείχνει πόσο καλύτερη απόδοση είναι όταν χρησιμοποιείτε το F# 5 και τα τελευταία εργαλεία για το F# σε σύγκριση με μόλις πριν από ένα χρόνο.

Η απόδοση είναι κάτι που λειτουργεί συνεχώς και οι βελτιώσεις προέρχονται συχνά από τους συνεισφέροντες ανοιχτού κώδικα. Μερικοί από αυτούς περιλαμβάνουν τον Steffen Forkmann, τον Eugene Auduchinok, τον Chet Hust, τον Saul Rennison, τον Abel Braaksma, τον Isaac Abraham και πολλά άλλα. Κάθε έκδοση διαθέτει εκπληκτική δουλειά από τους συνεισφέροντες ανοιχτού κώδικα. Είμαστε αιώνια ευγνώμονες για τη δουλειά τους.

Το συνεχές ταξίδι F# και πώς να εμπλακείτε

Η ομάδα της Microsoft F# είναι πολύ ενθουσιασμένη για να κυκλοφορήσει το F# 5 φέτος και ελπίζουμε ότι θα το λατρέψετε όσο κι εμείς. Το F# 5 αντιπροσωπεύει την έναρξη ενός νέου ταξιδιού για εμάς. Ανυπομονώ, θα βελτιώσουμε συνεχώς τις διαδραστικές εμπειρίες για να κάνουμε το F# την καλύτερη επιλογή για σημειωματάρια και άλλα διαδραστικά εργαλεία. Θα πάμε βαθύτερα στο σχεδιασμό της γλώσσας και θα συνεχίσουμε να υποστηρίζουμε βιβλιοθήκες όπως το Diffsharp για να κάνουμε μια επιτακτική επιλογή για μηχανική μάθηση. Και όπως πάντα, πρόκειται να βελτιώσουμε τα βασικά στοιχεία του μεταγλωττιστή και των εργαλείων και να ενσωματώσουμε γλωσσικά χαρακτηριστικά που μπορούν να απολαύσουν ο καθένας.

Θα θέλαμε να σας δούμε να έρχεστε και για τη βόλτα. Το F# είναι εξ ολοκλήρου ανοικτού κώδικα, με προτάσεις γλώσσας, σχεδιασμό γλώσσας και βασική ανάπτυξη που συμβαίνουν στο GitHub. Υπάρχουν μερικοί εξαιρετικοί συνεισφέροντες σήμερα και αναζητούμε περισσότερους συνεισφέροντες που θέλουν να μειώσουν τον τρόπο με τον οποίο εξελίσσονται η γλώσσα και τα εργαλεία F#.

Για να συμμετάσχετε σε τεχνικό επίπεδο, δείτε τους ακόλουθους συνδέσμους:

• F# προτάσεις γλώσσας: https: // github.com/fsharp/fslang-suggestions
• F# Σχεδιασμός γλώσσας: https: // github.com/fsharp/fslang-design
• F# Ανάπτυξη: https: // github.com/dotnet/fsharp
• F# τρέχει στο javascript: https: // fable.IO/
• F# Εργαλεία για τον κώδικα Visual Studio: http: // ionide.IO/
• F# Εκτέλεση στο Web Assembly: https: // fsbolero.IO/

Το Ίδρυμα Λογισμικού F# φιλοξενεί επίσης μια μεγάλη κοινότητα Slack, εκτός από το να είναι ένα κεντρικό σημείο για διάφορες υποεπιχειρήσεις να μοιράζονται πληροφορίες μεταξύ τους. Είναι ελεύθερο να συμμετάσχετε, οπότε κατευθυνθείτε στον ιστότοπο εδώ για να μάθετε περισσότερα: http: // ίδρυμα.φουσκωτό.org/ένωση

Θέλετε να έχετε λόγο στο πού πηγαίνει το F# και πώς το κάνει? Ελα μαζί μας. Θα θέλαμε να συνεργαστούμε.

Σημειωματάρια jupyter

Τα σημειωματάρια Jupyter είναι ένα διαδραστικό εργαλείο προγραμματισμού που σας επιτρέπει να αναμιγνύετε το Markdown και τον Code σε ένα έγγραφο. Ο κώδικας μπορεί να εκτελεστεί στο σημειωματάριο, συχνά για την παραγωγή δομημένων δεδομένων ή διαγραμμάτων που συμβαδίζουν με μια εξήγηση με μια εξήγηση.

Τα σημειωματάρια Jupyter ξεκίνησαν ως Ipython, ένα διαδραστικό εργαλείο προγραμματισμού για προγράμματα Python. Έχει αυξηθεί για να υποστηρίξει πολλές διαφορετικές γλώσσες και είναι τώρα ένα από τα πρωτογενή εργαλεία που χρησιμοποιούνται από τους επιστήμονες δεδομένων στο έργο τους. Χρησιμοποιείται επίσης ως εκπαιδευτικό εργαλείο.

Πίνακας 1: Χρόνος μεταγλώττισης για το Fsharpplus.DLL σε πρόσφατες εκδόσεις F#

F# Γλώσσα προγραμματισμού: Ιστορία, οφέλη και μελλοντικές δυνατότητες

Οι προγραμματιστές Nescient θα μπορούσαν να κάνουν το λάθος να προφέρουν το όνομα ως F ‘Χασίσι’ Αλλά αυτό θα κερδίσει μερικά περιφρονητικά μάτια από τα Adept Ones στον προγραμματιστή’κοινότητα. Το F Sharp (επειδή το # είναι προφέρεται ως αιχμηρό) είναι μια γλώσσα προγραμματισμού ανοιχτού κώδικα, έντονα δακτυλογράφηση, πολλαπλών παραλλαγών. Η γλώσσα προγραμματισμού πολλαπλών παραμέτρων είναι συμπεριλαμβανομένου του λειτουργικού, επιτακτικού και αντικειμενοστραφής προγραμματισμού

Κάθε γλώσσα προγραμματισμού μπορεί να πέσει σε μία από τις δύο κατηγορίες. δακτυλογραφημένη και ασθενώς δακτυλογραφημένη.

Οι έντονα δακτυλογραφημένες γλώσσες έχουν εξαιρετικά επιθετικούς κανονισμούς κατά το χρόνο μεταγλώττισης, υποδηλώνοντας ότι τα σφάλματα και οι εξαιρέσεις είναι πιο πιθανό να συμβούν. Η πλειοψηφία αυτών των κανονισμών επηρεάζει τις τιμές επιστροφής, τις μεταβλητές αναθέσεις και την κλήση λειτουργιών.

Ενώ η ασθενώς πληκτρολογημένη γλώσσα είναι το αντίθετο και έχει χαλαρά κανόνες πληκτρολόγησης που μπορούν να χαιρετίσουν απρόβλεπτα αποτελέσματα ή μπορεί να προκαλέσουν σιωπηρή μετατροπή τύπου κατά το χρόνο εκτέλεσης.

Το Multi-Paradigm αναφέρεται στην υποστήριξη περισσότερων από ένα παραδείγματος προγραμματισμού για να επιτρέψει στους προγραμματιστές να επιλέξουν το καταλληλότερο στυλ προγραμματισμού και τις σχετικές δομές γλώσσας για ένα συγκεκριμένο έργο.

Συχνά χρησιμοποιείται ως CLI cross-platform (υποδομή κοινής γλώσσας) και μπορεί επίσης να δημιουργήσει κωδικό JavaScript και GPU (μονάδα επεξεργασίας γραφικών).

Αναπτύσσεται από το F# Software Foundation και τη Microsoft μαζί με άλλους ανοικτούς συνεισφέροντες.

Σύντομη Ιστορία

Το F# δημιουργήθηκε για πρώτη φορά το 2005, όταν αναπτύχθηκε από την Microsoft Research. Αρχικά, ήταν .Net (προφέρεται ως dot net) Εφαρμογή του OCAML αφού συνδυάζει τη δύναμη και τη σύνταξη της λειτουργικής γλώσσας με χιλιάδες λειτουργίες βιβλιοθήκης διαθέσιμες με .Καθαρές γλώσσες.

Από το 2005, το F# έχει περάσει από πολλές απαραίτητες αλλαγές και οι προγραμματιστές έκαναν διάφορες εκδόσεις που το έκαναν καλύτερο από το πρώτο. Ξεκινώντας από την άδεια Apache, έκανε τη γλώσσα προγραμματισμού μια ανοιχτή προερχόμενη που σήμαινε ότι μπορεί να τροποποιηθεί, να διανεμηθεί και να χρησιμοποιηθεί χωρίς να πληρώνει στους αρχικούς προγραμματιστές.

Η πρώτη έκδοση που ξεκίνησε το 2005 ήταν μόνο συμβατή με τα Windows και αναπτύχθηκε .Καθαρό 1.0 έως 3.5 Χρόνος εκτέλεσης. Η στενή βάση πλατφόρμας ήταν η μεγαλύτερη αδυναμία αυτής της έκδοσης. Το ζήτημα αντιμετωπίστηκε στην επόμενη έκδοση που αναπτύχθηκε με την προσθήκη τόσο του OS X όσο και του Linux στις υποστηριζόμενες πλατφόρμες στην έκδοση 2.0 που ξεκίνησε το 2010.
Το 2012, ο F# είδε την προσθήκη JavaScript και GPU στις υποστηριζόμενες πλατφόρμες. Η τελευταία έκδοση ξεκίνησε το 2015 που ήταν 4.0.

Μέλλον του f#

Πολλοί άνθρωποι ισχυρίζονται ότι το F# είναι μία από τις πιο δημοφιλείς, υποτιμημένες και υποεκπροσωπούμενες γλώσσες προγραμματισμού. Αλλά υπάρχει μια άλλη πλευρά στην ιστορία. Σύμφωνα με το StackOverflow. Το F# έχει ψηφιστεί τη γλώσσα που σχετίζεται με τον υψηλότερο μισθό παγκοσμίως.

Η ίδια έρευνα δείχνει ότι το F# δεν’t εμφανίζεται στις 25 κορυφαίες γλώσσες προγραμματισμού που χρησιμοποιούνται σε ολόκληρο τον κόσμο. Η γλώσσα παραμένει στο περιθώριο, παρά το γεγονός ότι έχει μια πραγματικά ενεργή κοινότητα.

Αλλά γιατί οι προγραμματιστές αγαπούν να δουλεύουν με το F# αν’τόσο μη δημοφιλής? Δημιουργήθηκε και συντηρείται από τον Don Syme, το F# ήταν συγκριτικά ανθεκτικό σε μερικές από τις υποτιθέμενες υπερβολικές περιπτώσεις που υιοθέτησαν παρόμοιες γλώσσες FP όπως η Scala. Αυτή η αντίσταση διατηρεί την προσβασιμότητα για τους προγραμματιστές από τον έξω κόσμο που μπορεί να ενδιαφέρονται για το Dabbling σε λειτουργικό προγραμματισμό.

Το F# έχει εξαιρετική χρήση όταν πρόκειται για ανάπτυξη με βάση τα δεδομένα και την ανάπτυξη του τομέα. Τώρα μπορεί επίσης να καταρτιστεί στο JavaScript που είναι ο κόσμος’πιο δημοφιλείς γλώσσες. Με αυτόν τον σύνδεσμο Secure, έχει επίσης πρόσβαση στο JavaScript’εκτεταμένες βιβλιοθήκες και βάση συσκευών.

Το F# έχει κάνει το σημάδι του όταν ήρθε σε τεχνητή νοημοσύνη, μηχανική μάθηση και συναφή ανάλυση δεδομένων. Ήταν ο ίδιος ο σκοπός της δημιουργίας του F#. Λόγω της τεράστιας κλίμακας και της αναμενόμενης επιρροής, η τεχνητή νοημοσύνη θα έχει στα γλωσσικά οικοσυστήματα και την τεχνολογία γενικά, έχοντας μια γλώσσα τόσο κατάλληλη για την ανάπτυξη των θέσεων σε αυτό μια ισχυρή θέση για να αναπτυχθεί γρήγορα και ακόμη και να προκαλέσει δημοφιλείς γλώσσες όπως το JavaScript και το Python στο μέλλον.

Τι σταματά F#’ανάπτυξη?

Αν και φαίνεται σαν ένα σκληρό γεγονός να χωνέψει, η ευθύνη για αυτό αποδίδεται κυρίως στους δημιουργούς του, που είναι η Microsoft. Έχουν περιορίσει τη δημοτικότητα του F# αφήνοντας C# να ανθίσει εκεί έξω. Η Microsoft έχει κάνει το F# κατώτερο στο C#.

Υπάρχει μια κυκλική κίνηση σε αυτό. Λίγες θέσεις εργασίας υπάρχουν για το F# επειδή υπάρχουν λίγοι προγραμματιστές F# εκεί έξω και υπάρχουν λιγότεροι προγραμματιστές F# εκεί έξω επειδή υπάρχουν λιγότερες θέσεις εργασίας F#. Αλλά αργά αλλά σίγουρα, αυτή η τάση αλλάζει.

Πίδακας.Η Com ήταν η πρώτη μεγάλη εταιρεία που υιοθέτησε τη χρήση του F#. Αργότερα, ο Kaggle και πολλές οικονομικές και ασφαλιστικές εταιρείες ακολούθησαν επίσης.

Οι προγραμματιστές του F# στερούνται προσπάθειες να το κάνουν πιο δημοφιλείς και με χαρακτηριστικά ως μια γλώσσα πολλαπλών παραμέτρων που χρησιμοποιείται πολύ στο AI, το καλύτερο πράγμα που πρέπει να κάνετε είναι να επικεντρωθείτε στα βασικά οφέλη του F# που είναι μικρότερα χρονικά διαστήματα, λιγότερα σφάλματα και υψηλότερη παραγωγικότητα. Εάν προωθηθεί με την προβολή αυτών των χαρακτηριστικών, μπορεί να βοηθήσει να ανεβείτε στη σκάλα της δημοτικότητας γρηγορότερα από πριν.

Το F# κρατάει πραγματικά το πλεονέκτημα έναντι του C#?

Ήδη εξοικειωμένο με το C#? Στη συνέχεια, μάθετε πώς να προγραμματίσετε το δικό σας παιχνίδι breakout χρησιμοποιώντας το C#.

• Το F# κάνει πολλές κοινές εργασίες προγραμματισμού απλούστερα. Αυτό συνεπάγεται πράγματα όπως η δημιουργία και η χρήση σύνθετων ορισμών τύπου, η επεξεργασία λιστών, οι μηχανές κατάστασης, η ισότητα και η σύγκριση και πολλά άλλα.
• Χωρίς ημικόλια, σγουρές αγκύλες και τέτοια, σε F# σχεδόν ποτέ δεν χρειάζεται να καθορίσετε τον τύπο ενός αντικειμένου λόγω της παρουσίας ενός ισχυρού συστήματος συμπερασμάτων τύπου. Χρειάζονται επίσης λιγότερες γραμμές κωδικών για την επίλυση αυτού του ζητήματος επίσης
• Το F# είναι μια λειτουργική γλώσσα, αλλά υποστηρίζει άλλα στυλ που αρένα’T εντελώς καθαρό, καθιστώντας πολύ πιο εύκολο να αλληλεπιδράσετε με το μη-κατάλληλο πεδίο των βάσεων δεδομένων, των ιστότοπων και ούτω καθεξής. Συγκεκριμένα, το F# έχει σχεδιαστεί ως λειτουργική γλώσσα υβριδίου/OO, οπότε είναι σε θέση να κάνει τα πάντα ως C#. Αν και το F# ενσωματώνεται απρόσκοπτα με το .Καθαρό οικοσύστημα που σας επιτρέπει να έχετε πρόσβαση σε όλα τα τρίτα μέρη .Καθαρά εργαλεία και βιβλιοθήκες.
• Το F# είναι μέρος του Visual Studio που σας επιτρέπει να πάρετε έναν καλό επεξεργαστή με μια υποστήριξη IntelliSense, ένα Debugger και πολλά plugins για δοκιμές μονάδων, έλεγχο προέλευσης και άλλα αναπτυξιακά καθήκοντα.

F# Future

Παρόμοια με ένα ασύμ < >μπλοκ αλλά καταγράφει το αποτέλεσμα για μελλοντική κατανάλωση. Αυτή η δομή μπορεί να είναι πολύ χρήσιμη για την εκτέλεση πολλαπλών λειτουργιών επιστροφής αποτελεσμάτων παράλληλα όταν τα αποτελέσματα δεν χρειάζονται αμέσως. Για παράδειγμα, εκτέλεση αρκετών λειτουργιών ανάγνωσης/μετασχηματισμού ή προ-διατύπωση μνήμης cache με υπολογισμένες τιμές που πρέπει να είναι ακόμα υπολογισμένες τιμές. Παράλληλη βιβλιοθήκη εργασίας της Microsoft στο .Καθαρό 4.Το 0 περιλαμβάνει μια μελλοντική εφαρμογή, οπότε αυτή η έκδοση απαιτείται μόνο νωρίτερα .Καθαρές εκδόσεις. Τα σχόλια, οι προτάσεις και οι βελτιώσεις είναι πάντα ευπρόσδεκτες.

 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: 

Άνοιξε Σύστημα Άνοιξε Σύστημα.Συστατικό Άνοιξε Σύστημα.Νήμα /// Εκτελεί έναν υπολογισμό σε έναν εργαζόμενο στο παρασκήνιο και συγχρονίζεται στην επιστροφή του αποτελέσματος. ο /// Ο υπολογισμός ξεκινά αμέσως και καλεί μπλοκ &laquo;αξίας&raquo; έως ότου το αποτέλεσμα είναι έτοιμο. τύπος Μελλοντικός"Τ>(φά : μονάδα -> "Τ· = /// αποτέλεσμα του υπολογισμού στην κανονική έξοδο. αφήνω ευμετάβλητος αποτέλεσμα :"Τ επιλογή = Κανένας /// αποτέλεσμα αν ρίχτηκε μια εξαίρεση. αφήνω ευμετάβλητος εκ των υστέρων : Εξαίρεση επιλογή = Κανένας αφήνω συγχρόνω = νέος Αντικείμενο() /// αντικείμενο παλμού που χρησιμοποιείται για να περιμένετε μέχρι να είναι έτοιμο αποτέλεσμα. Βεβαιωθείτε ότι το Pullse () χρησιμοποιείται έτσι /// δεν χρειάζεται να δημιουργήσετε το αντικείμενο εάν το αποτέλεσμα γίνει πριν χρειαστεί. αφήνω ευμετάβλητος σφυγμός : Εγχειρίδιο = μηδενικό αφήνω βεβαιωθείτε() = κλειδαριά συγχρόνω (διασκέδαση () -> αγώνας σφυγμός με | μηδενικό -> σφυγμός  νέος Εγχειρίδιο(ψευδής) | _ -> () σφυγμός· /// Προειδοποίηση: Κλήση Μόλις πραγματοποιηθεί ήδη μια κλειδαριά στο Syncroot. Παλεύει τον ειδοποιητή αναμονής. Ασφαλές εάν /// Ονομάζεται μετά το &laquo;pulse&raquo; δημιουργείται, αλλά πριν καλέσει το waitone. αφήνω Notifywaiters() = αν σφυγμός <> μηδενικό έπειτα σφυγμός.Σειρά() |> αγνοώ αφήνω δουλειά = νέος Εργαζόμενος() /// on runworkerasync (), εκτελέστε καθορισμένη λειτουργία και αποτέλεσμα αποθήκευσης. Όλες οι εξαιρέσεις πρέπει να είναι /// παγιδευμένος. κάνω δουλειά.Δούλεψε.Προσθήκη( διασκέδαση args -> δοκιμάστε αποτέλεσμα  Μερικοί( φά()) με μι -> εκ των υστέρων  Μερικοί μι κλειδαριά συγχρόνω ( <
span >διασκέδαση () -> Notifywaiters(())) /// Ξεκινήστε αμέσως/ αυτόματα. κάνω δουλειά.Runworkerasync() /// επιστρέφει την τιμή του υπολογισμού, εμποδίζοντας εάν το αποτέλεσμα δεν είναι έτοιμο ακόμα. μέλος Τ.αξία = // Εάν υπάρχει, μπορούμε να το επιστρέψουμε αμέσως. αγώνας αποτέλεσμα με | Μερικοί Χ -> Χ | Κανένας πότε εκ των υστέρων.Ερασιτέχνης -> υψώνω (Επιλογή.παίρνω εκ των υστέρων) | Κανένας -> αφήνω Π = βεβαιωθείτε() // Ελέγξτε ξανά σε περίπτωση που άλλαξε ενώ μπήκαμε στο αντικείμενο αναμονής. αγώνας αποτέλεσμα με | Μερικοί Χ -> Χ | Κανένας -> // Το κλειδί-ελεύθερο είναι εντάξει γιατί αν ο παλμός.Η μέθοδος (), καλείται από το πότε εμείς // checked 'αποτέλεσμα' και καλέστε το waitone εδώ, ο WaitOne θα επιστρέψει αμέσως. Π.Όριο μίσχας(1000000000· |> αγνοώ αγώνας αποτέλεσμα με | Μερικοί Χ -> Χ | Κανένας -> αν εκ των υστέρων.Ερασιτέχνης έπειτα υψώνω (Επιλογή.παίρνω εκ των υστέρων· αλλού αποτυγχάνω "Ο μελλοντικός υπολογισμός απέτυχε.&laquo; /// επιστρέφει αληθές εάν ο υπολογισμός έχει τελειώσει, ψευδές αν όχι. μέλος Τ.Ειναι ΟΛΟΚΛΗΡΩΜΕΝΟ = αγώνας αποτέλεσμα με | Μερικοί Χ -> αληθής | Κανένας πότε Επιλογή.ερασιτέχνης εκ των υστέρων -> αληθής | Κανένας -> ψευδής 

σύστημα ονομάτων

σύστημα ονομάτων.Συστατικό

σύστημα ονομάτων.Νήμα

Πολλά αντικείμενα
πληκτρολογήστε το μέλλον =
Νέο: F: (Μονάδα -> 'T) -> Μέλλον
Μέλος ISComplete: Bool
τιμή μέλους: 't

Πλήρες όνομα: σενάριο.Μελλοντικός

Εκτελεί έναν υπολογισμό σε έναν εργαζόμενο στο παρασκήνιο και συγχρονίζεται στην επιστροφή του αποτελέσματος. ο
Ο υπολογισμός ξεκινά αμέσως και καλεί τα μπλοκ &laquo;αξίας&raquo; έως ότου το αποτέλεσμα είναι έτοιμο.

Val F: (Μονάδα -> 'T)

μονάδα τύπου = μονάδα

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.μονάδα

Val Μεταβλητό αποτέλεσμα: 'T Επιλογή

Αποτέλεσμα του υπολογισμού στην κανονική έξοδο.

Τύπος 't Επιλογή = Επιλογή

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.επιλογή

Επιλογή περίπτωσης συνδικάτων.Κανένα: Επιλογή

Val Mutable Ext: Επιλογή εξαίρεσης

Αποτέλεσμα αν ρίχτηκε εξαίρεση.

Πολλά αντικείμενα
πληκτρολογήστε εξαίρεση =
Νέο: Μονάδα -> Εξαίρεση + 2 υπερφόρτωση
Δεδομένα μέλους: Idictionary
Μέλος GetBaseexception: Μονάδα -> Εξαίρεση
Μέλος GetObjectData: Πληροφορίες: SerializationInfo * Πλαίσιο: StreamingContext -> Μονάδα
Μέλος GetType: Μονάδα -> Τύπος
Μέλος Helplink: String with Get, Set
Μέλος Innerexception: Εξαίρεση
Μήνυμα μέλους: συμβολοσειρά
Πηγή μέλους: String with Get, Set
Μέλος StackTrace: String
.

Πλήρες όνομα: Σύστημα.Εξαίρεση

--------------------
Εξαίρεση (): Μονάδα
Εξαίρεση (Μήνυμα: String): Μονάδα
Εξαίρεση (Μήνυμα: String, Innerexception: EXN): Μονάδα

Val Syncroot: Αντικείμενο

Πολλά αντικείμενα
αντικείμενο τύπου =
Νέα: Μονάδα -> OBJ
Το μέλος ισούται με: OBJ: OBJ -> BOOL
Μέλος Gethashcode: Μονάδα -> int
Μέλος GetType: Μονάδα -> Τύπος
Μέλος ToString: Μονάδα -> String
Στατικό μέλος ισούται: obja: obj * objb: obj -> bool
Στατικό μέλος αναφοράς: obja: obj * objb: obj -> bool

Πλήρες όνομα: Σύστημα.Αντικείμενο

Val Mutable Pulse: ManualResetevent

Αντικείμενο παλμού που χρησιμοποιείται για να περιμένει έως ότου ένα αποτέλεσμα είναι έτοιμο. Βεβαιωθείτε ότι το Pullse () χρησιμοποιείται έτσι
δεν χρειάζεται να δημιουργήσετε το αντικείμενο εάν το αποτέλεσμα γίνει πριν χρειαστεί.

Πολλά αντικείμενα
Πληκτρολογήστε το ManualResetevent =
κληρονομούν εκδήλωση
Νέο: Αρχικό Σταθερό: Bool -> ManualResetevent

Πλήρες όνομα: Σύστημα.Νήμα.Εγχειρίδιο

--------------------
ManualResetevent (αρχική περιοχή: bool): μονάδα

Val Assetpulse: (Μονάδα -> ManualResetevent)

Val Lock: LockObject: 'Lock -> Δράση: (Μονάδα ->' T) -> 'T (απαιτεί τον τύπο αναφοράς)

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Φορείς εκμετάλλευσης.κλειδαριά

Val NotifyWaiters: (Μονάδα -> Μονάδα)

ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Κλήση Μόλις πραγματοποιηθεί ήδη μια κλειδαριά στο Syncroot. Παλεύει τον ειδοποιητή αναμονής. Ασφαλές εάν
Ονομάζεται μετά το "Pulse" δημιουργείται, αλλά πριν καλέσει το WaitOne.

Εκδήλωση.Set (): bool

Val Ignore: Value: 'T -> Μονάδα

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Φορείς εκμετάλλευσης.αγνοώ

Val Work: Backgroundworker

Πολλά αντικείμενα
πληκτρολογήστε εργαζόμενος στο φόντο =
κληρονομικό στοιχείο
Νέο: Μονάδα -> Εργαζόμενος στο παρασκήνιο
Μέλος CancelAsync: Μονάδα -> Μονάδα
Ακύρωση μέλους: Bool
Μέλος ISBUSY: BOOL
Αναφορά μέλους: PercentProgress: Int -> Unit + 1 υπερφόρτωση
Μέλος Runworkerasync: Μονάδα -> Μονάδα + 1 υπερφόρτωση
ΜΕΡΟΣ ΕΡΓΑΖΟΜΕΝΗ ΣΥΜΒΟΥΛΗ: BOOL με GET, SET
ΜΕΡΟΣ ΕΡΓΑΖΟΜΕΝΩΝ ΠΡΟΣΦΟΡΑΣΤΑΝΣΗ: BOOL με GET, SET
Εκδήλωση Dowork: Doworkeventhandler
Event ProgressChanged: ProgressHangedEventHandler
.

Πλήρες όνομα: Σύστημα.Συστατικό.Εργαζόμενος

εργαζόμενος στο γεγονός.Dowork: Ievent

μέλος iObservable.Προσθήκη: callback 🙁 't -> μονάδα) -> Μονάδα

Val args: Doworkeventargs

Επιλογή περίπτωσης συνδικάτων.Μερικά: Αξία: 'T -> Επιλογή

Val E: Exn

Εργαζόμενος.RunworkerAsync (): Μονάδα
Εργαζόμενος.Runworkerasync (επιχείρημα: OBJ): Μονάδα

Val T: Future

μέλλον μέλους.Αξία: 't

Πλήρες όνομα: σενάριο.Μελλοντικό '1.αξία

Στο RunworkerAsync (), εκτελέστε καθορισμένη λειτουργία και αποτέλεσμα αποθήκευσης. Όλες οι εξαιρέσεις πρέπει να είναι
παγιδευμένος.
Ξεκινήστε αμέσως / αυτόματα.
Επιστρέφει την τιμή του υπολογισμού, εμποδίζοντας εάν το αποτέλεσμα δεν είναι έτοιμο ακόμα.

επιλογή ιδιοκτησίας.Issome: Bool

Val raise: exn: εξαίρεση -> 't

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Φορείς εκμετάλλευσης.υψώνω

Val Get: Επιλογή: 'T Επιλογή ->' T

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Επιλογή.παίρνω

Val P: ManualResetevent

Παραπλανή.WaitOne (): Bool
Παραπλανή.WaitOne (χρονικό όριο: Timespan): Bool
Παραπλανή.WaitOne (MillisecondStimeout: Int): Bool
Παραπλανή.WaitOne (χρονικό όριο: Timespan, ExitContext: Bool): Bool
Παραπλανή.WaitOne (MillisecondStimeout: Int, ExitContext: Bool): Bool

Val Failwith: Μήνυμα: String -> 'T

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Φορείς εκμετάλλευσης.αποτυγχάνω

μέλλον μέλους.Iscomplete: bool

Πλήρες όνομα: σενάριο.Μελλοντικό '1.Ειναι ΟΛΟΚΛΗΡΩΜΕΝΟ

Επιστρέφει αληθές εάν ο υπολογισμός έχει τελειώσει, ψευδές αν όχι.

Val Issome: Επιλογή: 'T Επιλογή -> Bool

Πλήρες όνομα: Microsoft.Φουσκωτό.Πυρήνας.Επιλογή.ερασιτέχνης

Αντιγραφή συνδέσμου αντιγραφής αντιγραφής πρώτης προβολής κώδικα δοκιμής νέα έκδοση

Περισσότερες πληροφορίες

Οικοδόμηση λειτουργικού .Καθαρές εφαρμογές: Οδηγός για την επιλογή μεταξύ F# vs C#

Η αποτελεσματικότητα είναι όλα στον κόσμο της ανάπτυξης των εφαρμογών. Οι προγραμματιστές και οι οργανισμοί που μπορούν να πάρουν τα προϊόντα στην αγορά γρηγορότερα και να παρέχουν πιο γρήγορη ανανέωση θα έχουν πάντα ένα πλεονέκτημα σε σχέση με τον ανταγωνισμό.

Έτσι, όλοι αναζητούν τρόπους για να μειώσουν τον χρόνο ανάπτυξης, τον χρόνο που δαπανάται για το εντοπισμό σφαλμάτων και των δοκιμών, καθώς και ο χρόνος που πιέζει τις τελικές απελευθερώσεις στους πελάτες.

Ο λειτουργικός προγραμματισμός ήταν σε κοινή χρήση πριν από δεκαετίες, αλλά έχασε γρήγορα το έδαφος σε αντικειμενικές γλώσσες προγραμματισμού, οι οποίες σύντομα έγιναν το de facto πρότυπο.

Σχετικό περιεχόμενο που χορηγεί

Σχετικός χορηγός

Κωδικός, ανάπτυξη και κλίμακα Java Ο τρόπος σας.
Η Microsoft Azure υποστηρίζει το φόρτο εργασίας σας με άφθονες επιλογές, είτε εργάζεστε σε μια εφαρμογή Java, έναν διακομιστή εφαρμογών ή ένα πλαίσιο. Μάθε περισσότερα.

Αλλά τα τελευταία χρόνια, υπήρξε αναζωπύρωση ενδιαφέροντος για τον λειτουργικό προγραμματισμό ως τρόπο βελτίωσης της αποτελεσματικότητας της ανάπτυξης και την οικοδόμηση πιο σταθερών και ισχυρών εφαρμογών.

Τα C# και F# είναι γλώσσες με αναπτυσσόμενες βάσεις χρηστών που προσεγγίζουν τον λειτουργικό προγραμματισμό με θεμελιωδώς διαφορετικούς τρόπους: C# ως συμπλήρωμα του εγγενούς επιτακτικού παραδείγματος και F# ως πρωταρχικό παράδειγμα του.

Αυτό το άρθρο διερευνά ποια από αυτές τις γλώσσες κάνει την καλύτερη δουλειά για προγραμματιστές που θέλουν να θέσουν λειτουργικό προγραμματισμό για τις ομάδες και τα έργα τους.

Η συζήτηση για τον λειτουργικό vs αντικειμενοστραφεί προγραμματισμό

Για να κατανοήσουμε τη συζήτηση, πρέπει να ξεκινήσουμε σε λίγο υψηλότερο επίπεδο με τη διαφορά μεταξύ επιτακτικών και δηλωτικών παραδειγμάτων προγραμματισμού.

• Επιτακτικός προγραμματισμός: Μια προσέγγιση προγραμματισμού βάσει διαδικασιών, όπου οι προγραμματιστές καθορίζουν τον τρόπο επίτευξης των αποτελεσμάτων βήμα προς βήμα. Ο επιτακτικός προγραμματισμός επικεντρώνεται στις αλλαγές του κράτους και του κράτους του προγράμματος. Οι αντικειμενικές γλώσσες προγραμματισμού όπως η Java και η C ++ ακολουθούν γενικά το επιτακτικό παράδειγμα.
• Δηλωτικός προγραμματισμός: Μια προσέγγιση προγραμματισμού προσανατολισμού των αποτελεσμάτων, όπου οι προγραμματιστές καθορίζουν τους τύπους των επιθυμητών αποτελεσμάτων. Ο δηλωτικός προγραμματισμός είναι απάτος και εντολή εκτέλεσης αγνωστικιστική. Λειτουργικές γλώσσες προγραμματισμού όπως οι Lisp, Python, Haskell και F# ακολουθούν το δηλωτικό πρότυπο προγραμματισμού.

Αλλά είναι μια υπεραπλούστευση για να προσπαθήσουμε και να διαιρέσουμε τακτοποιημένα όλες τις υπάρχουσες γλώσσες προγραμματισμού σε αυτές τις κατηγορίες, καθώς αρκετές γλώσσες προσφέρουν πτυχές του καθενός. Είναι γλώσσες υβριδικών ή πολλαπλών παραμέτρων.

Για παράδειγμα, παρόλο που η Java και η C ++ παραδοσιακά εμπίπτουν στην επιτακτική ταξινόμηση, έχουν επίσης λειτουργικές πτυχές. Το ίδιο ισχύει και για το C#. Ομοίως, αν και το F# θεωρείται λειτουργική γλώσσα, έχει επίσης επιτακτικές δυνατότητες.

Κοιτάξτε τη λίστα των κορυφαίων δέκα γλωσσών που χρησιμοποιούν οι προγραμματιστές. Θα δείτε ότι περιλαμβάνουν ως επί το πλείστον υβριδικές γλώσσες, με κάποιες να επικεντρώνονται στην επιταγή και άλλοι πιο κυρίαρχοι λειτουργικοί.

Το JavaScript, το οποίο έχει κρατήσει την πρώτη θέση σε αυτή την έρευνα για μια δεκαετία, είναι μια γλώσσα πολλαπλών παραλλαγών, προσφέροντας τόσο επιτακτικές, αντικειμενοστραφείς χαρακτηριστικά και λειτουργικά χαρακτηριστικά.

Δεδομένου του φάσματος υιοθεσίας, είναι χρήσιμο να εξετάσουμε τα διαφορετικά οφέλη που παρουσιάζει κάθε παράδειγμα και τις διάφορες περιπτώσεις χρήσης όπου το καθένα υπερέχει.

Επιτακτικός προγραμματισμός: Οφέλη και περιπτώσεις χρήσης

Μεταξύ των πρωταρχικών πλεονεκτημάτων του επιτακτικού παραδείγματος είναι ότι ο κώδικας που γράφεται χρησιμοποιώντας είναι γενικά εύκολα κατανοητό και μπορεί να είναι εύκολο να διαβαστεί. Επιπλέον, δεδομένης της σχολαστικής περιγραφής ροής εργασίας που απαιτεί επιτακτικός προγραμματισμός, ακόμη και οι αρχάριοι προγραμματιστές βρίσκουν εύκολο να ακολουθήσουν.

Αλλά το επίπεδο λεπτομέρειας επιτακτικός προγραμματισμός απαιτεί επίσης έρχεται με μειονεκτήματα. Για παράδειγμα, σε πιο πολύπλοκες εφαρμογές, ο κώδικας μπορεί γρήγορα να γίνει φουσκωμένος. Καθώς αυξάνεται το μέγεθος του κώδικα, η ευκολία ανάγνωσης και κατανόησης εξίσου γρήγορα πέφτει.

Επιπλέον, καθώς ο κώδικας επεκτείνεται, αυξάνεται η δυνατότητα για σφάλματα και σφάλματα. Έτσι, οι προγραμματιστές που εργάζονται με επιτακτικές γλώσσες συχνά βρίσκονται ξοδεύοντας πολύ χρόνο εντοπισμού σφαλμάτων και δοκιμών, καθυστερώντας τις απελευθερώσεις προϊόντων.

Παρ 'όλα αυτά, ο επιτακτικός προγραμματισμός παραμένει απίστευτα δημοφιλής και έχει ένα ευρύ φάσμα περιπτώσεων χρήσης. Οι παραδοσιακές εφαρμογές για επιτακτικό προγραμματισμό περιλαμβάνουν:

• Hypertext και hypermedia
• Συστήματα διαχείρισης βάσης δεδομένων αντικειμένων (ODBMS)
• Συστήματα πελάτη-διακομιστή
• Συστήματα σε πραγματικό χρόνο
• Τεχνητή νοημοσύνη, μηχανική μάθηση και νευρωνικά δίκτυα
• Αυτοματοποίηση

Λειτουργικός προγραμματισμός: Οφέλη και περιπτώσεις χρήσης

Τα οφέλη του λειτουργικού προγραμματισμού προσγειώνονται περισσότερο στην πλευρά της απόδοσης της εξίσωσης. Ο λειτουργικός κώδικας, ενώ είναι λιγότερο εύκολος στην ανάγνωση και κατανόηση με την πρώτη ματιά, τείνει να είναι πιο κοντά στο χωρίς σφάλματα (i.μι., Χωρίς παρενέργειες για τις αλλαγές κατάστασης), μειώνοντας τον χρόνο προγραμματιστή που δαπανάται για το σφάλμα και τη δοκιμή.

Λιγότερα σφάλματα προσφέρεται επίσης σε πιο ασφαλείς εφαρμογές, περιορίζοντας την επιφάνεια επίθεσης για τους εγκληματίες στον κυβερνοχώρο για να μειώσουν τις πιθανότητες επιθέσεων ransomware, κακόβουλο λογισμικό ή ενέσεις SQL.

Ο λειτουργικός προγραμματισμός είναι επίσης καλύτερος τόσο στην παράλληλη επεξεργασία όσο και στην τεμπέλης αξιολόγηση. Επιπλέον, ο λειτουργικός κώδικας είναι πιο αρθρωτός και επαναχρησιμοποιούμενος, μειώνοντας την ανάγκη για περιττό κωδικό. Το μικρότερο σύνολο κώδικα είναι ευκολότερο να διατηρηθεί και μπορεί να είναι υψηλότερη απόδοση. Ωστόσο, ο λειτουργικός κώδικας μπορεί να είναι εντατικός στη μνήμη, εξαλείφοντας τυχόν οφέλη ταχύτητας από το μειωμένο μέγεθος κώδικα και οδηγώντας στην πραγματικότητα σε μειωμένη συνολική απόδοση.

Ο λειτουργικός προγραμματισμός είναι ιδιαίτερα δημοφιλής στους ακαδημαϊκούς και τους επιστήμονες δεδομένων, επειδή είναι αποτελεσματικό στην αντιμετώπιση του χειρισμού μεγάλων συνόλων δεδομένων.

Δεδομένης της εστίασής του στην παράλληλη επεξεργασία και αμετάβλητη, ο λειτουργικός προγραμματισμός είναι ιδιαίτερα χρήσιμος για:

• Επιστημονικά δεδομένα
• Εφαρμογές υπολογιστικού φύλλου
• Εφαρμογές χρηματοδότησης και κινδύνου
• Επεξεργασία παρτίδας

Λειτουργικός προγραμματισμός: C# VS F#

C# και F# είναι γλώσσες που έχουν κερδίσει σε δημοτικότητα τα τελευταία χρόνια. Παρόλο που είναι και οι δύο πολλαπλασιασμοί, η κύρια εστίασή τους διαφέρει, με την C# να βασίζεται σε αντικειμενοστραφείς, επιτακτικές αρχές και να βασίζεται στις λειτουργικές αρχές. Αλλά το ένα ξεπεράσει το άλλο όταν πρόκειται για λειτουργικό προγραμματισμό?

Τι είναι το C#, και ποιος το χρησιμοποιεί?

Το C# είναι μια γλώσσα Multi-Paradigm, αντικειμενοστραφής που κυκλοφόρησε για πρώτη φορά από τη Microsoft πριν από περίπου 20 χρόνια. Όπως μπορείτε να δείτε από τα παραπάνω στατιστικά στοιχεία χρήσης, ήταν η όγδοη πιο δημοφιλής γλώσσα μεταξύ των προγραμματιστών το 2022, με σχεδόν το ένα τρίτο των προγραμματιστών να το χρησιμοποιούν. Έχει επίσης υψηλές βαθμολογίες ικανοποίησης, με τα δύο τρίτα των χρηστών C# λέγοντας ότι αγαπούν το χρησιμοποιώντας το.

Το C# βρίσκει πολλές χρήσεις στην ανάπτυξη υπηρεσιών ιστού και cloud, καθώς και ανάπτυξη παιχνιδιών. Οι εταιρείες από τη Microsoft στο TrustPilot στο StackOverFlow δημιουργούν εφαρμογές και υπηρεσίες με το C#.

Λειτουργικός προγραμματισμός στο C#

Παρόλο που το C# είναι κυρίως αντικειμενοστραφές και μεταβλητό/κρατικό, έχει λειτουργικές δυνατότητες. Ακολουθούν μερικοί τρόποι για την εφαρμογή του λειτουργικού παραδείγματος στο C#.

Δημιουργία αμετάβλητου

Επειδή οι τύποι δεδομένων στο C# είναι εγγενώς μεταβλητοί, όταν θέλετε να χρησιμοποιήσετε λειτουργικές αρχές προγραμματισμού, πρέπει να δημιουργήσετε αμετάβλητη. Και αυτό είναι πιο περίπλοκο από το να βασίζεται απλώς σε αμετάβλητους τύπους δεδομένων στο F#. Συγκεκριμένα, για να δημιουργήσετε αμετάβλητους τύπους στο C#, πρέπει να κάνετε τον τύπο μόνο για ανάγνωση, να αφαιρέσετε τις ιδιότητες του setter, να χρησιμοποιήσετε έναν κατασκευαστή για να παρέχετε τις παραμέτρους και στη συνέχεια να δημιουργήσετε μια νέα παρουσία κάθε φορά που απαιτείται μια αλλαγή κατάστασης, αντί να μεταλλάξετε ένα υπάρχον παράδειγμα.

Χρησιμοποιήστε εκφράσεις Linq και Lambda

Η Microsoft δημιούργησε το πλαίσιο LINQ (Language Integrated Query) ειδικά για την εισαγωγή λειτουργικών χαρακτηριστικών προγραμματισμού στο C#. Το LINQ παρέχει λειτουργίες για τη λειτουργία σε λίστες ή ακολουθίες, συμπεριλαμβανομένης της χαρτογράφησης (επιλογής), της ταξινόμησης (orderBy) και του φιλτράρισμα (όπου). Κάθε μία από αυτές τις εκφράσεις έχει λειτουργίες για επιχειρήματα. Οι εκφράσεις δημιουργούν νέες περιπτώσεις της ακολουθίας και όχι με τη μετάλλαξη της υπάρχουσας ακολουθίας. Το LINQ είναι ιδιαίτερα χρήσιμο για την ερώτηση δεδομένων, είτε πρόκειται για πίνακες SQL, δεδομένα XML ή άλλες πηγές.

Το LINQ επιτρέπει επίσης τη χρήση εκφράσεων Lambda, οι οποίες είναι ουσιαστικά ανώνυμες λειτουργίες. Οι ανώνυμες λειτουργίες αποτελούν βασική πτυχή του λειτουργικού προγραμματισμού. Οι εκφράσεις Lambda μπορούν να λειτουργήσουν ως επιχειρήματα για άλλες λειτουργίες στον κώδικα, δημιουργώντας λειτουργίες υψηλότερης τάξης, ένα άλλο κοινό χαρακτηριστικό του λειτουργικού προγραμματισμού.

Χρησιμοποιήστε αλυσίδες μεθόδου

Ένα συνήθως χρησιμοποιούμενο χαρακτηριστικό του F# είναι ο χειριστής αγωγών, ο οποίος περνάει το αποτέλεσμα μιας λειτουργίας σε μια άλλη λειτουργία. Η αγωγιμότητα δεν είναι ενσωματωμένη στο C, αλλά οι προγραμματιστές μπορούν να μιμηθούν αγωγούς σε ορισμένες περιπτώσεις χρησιμοποιώντας αλυσίδες μεθόδων ή διεπαφές άπταιστα. Αυτό μπορεί να πραγματοποιηθεί χρησιμοποιώντας τη λειτουργικότητα StringBuilder στο C#.

Οι αλυσίδες μεθόδου σας επιτρέπουν επίσης να αναπαράγετε ένα άλλο κοινό χαρακτηριστικό του λειτουργικού προγραμματισμού, κάρυ. Το Currying επιτρέπει σε μια λειτουργία με πολλαπλά επιχειρήματα να λαμβάνουν αυτά τα επιχειρήματα σε διαφορετικές χρονικές στιγμές. Ουσιαστικά, στον λειτουργικό προγραμματισμό, εάν μια συνάρτηση δεν λαμβάνει όλες τις απαραίτητες εισόδους, επιστρέφει μια νέα λειτουργία με τις εισόδους που λείπουν ως επιχειρήματα.

Στο C#, εφαρμόζετε κάρυ με αλυσίδες μεθόδων για να αποσυντεθείτε ένα επιχείρημα πολλαπλών λειτουργιών σε μια ένθετη ακολουθία διαφόρων λειτουργιών μεμονωμένων επιχειρημάτων. Ωστόσο, αυτό δεν είναι τόσο τακτοποιημένο όσο και αποτελεσματικό όπως στο F#.

Αυτοί είναι μόνο μερικοί από τους τρόπους με τους οποίους οι εξειδικευμένοι προγραμματιστές C# μπορούν να εφαρμόσουν λειτουργικές αρχές προγραμματισμού στο C#. Και ενώ μπορούν να απαιτήσουν περισσότερη προσπάθεια απ 'ό, τι απλά χρησιμοποιούν το F#, για εκείνους τους προγραμματιστές που θέλουν όλα τα άλλα χαρακτηριστικά που έχουν να προσφέρουν το C#, είναι μια βιώσιμη εναλλακτική λύση.

Τι είναι το F#, και ποιος το χρησιμοποιεί?

Αρχικά κυκλοφόρησε η Microsoft για την πλατφόρμα Windows το 2005, το F# είναι μια κατά κύριο λόγο λειτουργική γλώσσα προγραμματισμού. Επέκτασε για να περιλαμβάνει πλατφόρμες Linux και MacOS το 2010, και στη συνέχεια JavaScript το 2013. Επίσης, το 2013, το F# Software Foundation ξεκίνησε για να υποστηρίξει τη Microsoft στην ανάπτυξή του και τόσο το F# όσο και την κοινότητα F#.

Από την ίδρυσή της, η κοινότητα F# έχει αυξηθεί σταθερά, αν αργά. Περιλαμβάνει τώρα έναν όμιλο Github καθώς και πολλά διαφορετικά κοινοτικά έργα, από τους μεταφορείς JavaScript (Fable) έως τους διαχειριστές συσκευασίας (Paket) έως τις βιβλιοθήκες ανάπτυξης ιστού (Suave) και άλλα.

Παρά την ηλικία του, το F# έχει ακόμα σημαντικό χώρο για υιοθεσία. Οι στατιστικές γενικής χρήσης είναι λίγο δύσκολο να έρθουν, αλλά μια έρευνα του 2021 από jetbrains περισσότερων από 30000 προγραμματιστών ανέφερε ότι μόνο το 1% είχε χρησιμοποιήσει πρόσφατα το F# ή σχεδίαζε να το πράξει στο εγγύς μέλλον. Συγκριτικά, το 21% είχε χρησιμοποιήσει πρόσφατα C#και το 4% σχεδίαζε να το χρησιμοποιήσει σύντομα. Και το F# έχει ελαφρώς χαμηλότερη βαθμολογία ικανοποίησης από το C#, αν και περισσότερο από το 60% των προγραμματιστών λένε ότι αγαπούν το χρησιμοποιώντας το.

Επί του παρόντος, υπάρχουν λιγότερες από 100 εταιρείες που είναι γνωστό ότι χρησιμοποιούν το F# στην παραγωγή, αν και περιλαμβάνουν μερικά γνωστά ονόματα όπως Walmart και Huddle.

Μερικοί προγραμματιστές χρησιμοποιούν το F# ως συμπλήρωμα στο C#, αντί να βασίζονται στις λειτουργικές δυνατότητες που υπάρχουν εγγενώς στο C#. Επειδή και οι δύο μεταφέρονται προς .Καθαρές ενδιάμεσες γλώσσες (IL), είναι δυνατόν να χρησιμοποιηθούν και τα δύο στο ίδιο έργο.

Ποια γλώσσα έχει το πλεονέκτημα για λειτουργικό προγραμματισμό?

Φαίνεται ότι αυτό πρέπει να είναι μια πολύ απλή ερώτηση για να απαντήσετε: Το F# είναι λειτουργικό πρώτα, ενώ το C# είναι επιτακτικό πρώτα, οπότε η άκρη πηγαίνει στο F#. Και στο υψηλότερο επίπεδο, αυτή η δήλωση είναι αλήθεια. Αλλά η ανάπτυξη εφαρμογών, όπως η ζωή, είναι σπάνια αρκετά απλή για τη γενικευμένη εφαρμογή των αληθειών υψηλού επιπέδου.

Η καλύτερη ερώτηση που πρέπει να ρωτήσετε είναι ποια γλώσσα είναι κατάλληλη για εσάς, την ομάδα σας και τα έργα στα οποία εργάζεστε αυτή τη στιγμή. Και αυτό είναι ένα πολύ πιο περίπλοκο ερώτημα που πρέπει να απαντήσετε.

Επιλέγοντας τη σωστή γλώσσα για λειτουργικό προγραμματισμό

Όταν επιλέγετε μεταξύ C# και F# για τις λειτουργικές σας ανάγκες προγραμματισμού, υπάρχουν πολλές εκτιμήσεις που θα πρέπει να επηρεάζουν την απόφασή σας:

• Ποιες είναι οι ανάγκες του έργου? Τα συγκεκριμένα σύνολα χαρακτηριστικών της αίτησής σας ενδέχεται να σας οδηγήσουν σε μεγάλο βαθμό στη διαδικασία λήψης αποφάσεων. Για παράδειγμα, εάν τα πιο σημαντικά χαρακτηριστικά της εφαρμογής σας περιστρέφονται γύρω από τα στοιχεία διεπαφής χρήστη, με μόνο ελάχιστο χειρισμό δεδομένων, τότε μπορεί να θέλετε να εστιάσετε στο C#. Αλλά εάν η εφαρμογή σας είναι εντατική και τα στοιχεία UI είναι λιγότερο σημαντικά, πιθανότατα θα ακουμπήσετε προς το F#.
• Ποιο είναι το επίπεδο άνεσής σας με κάθε γλώσσα? Εάν η αίτησή σας θα επωφεληθεί από τον λειτουργικό προγραμματισμό, αλλά είστε&rsquo;T που βιώθηκε αρκετά με το C# για να αντιμετωπίσει εύκολα τους χειρισμούς που απαιτούνται για να κάνουν αμετάβλητους τύπους και να μεταφραστούν από δηλώσεις σε εκφράσεις, τότε θα πρέπει να εξετάσετε το F#.
• Πώς θα αντιμετωπίσει η ομάδα σας με διαφορετικές γλώσσες? Όταν εργάζεστε με μια ομάδα ανάπτυξης, πρέπει να εξετάσετε τα σύνολα δεξιοτήτων και την εμπειρία κάθε μέλους της ομάδας. Μπορεί να έχετε έναν πολύ εξειδικευμένο προγραμματιστή F#, αλλά άλλοι με ελάχιστη ή καθόλου έκθεση στο F#. Αυτό μπορεί να οδηγήσει σε δυσκολίες για τα μέλη της ομάδας στη συνεργασία με κώδικα που γράφτηκε από άλλους προγραμματιστές.
• Είναι μια καλύτερη προσέγγιση πολλαπλών γλωσσών? Είναι η ομάδα ανάπτυξης σας αρκετά εξειδικευμένη για να κάνει και τα δύο C# και F# να συνεργαστούν στο ίδιο έργο? Υπάρχουν λόγοι που οι οποιαδήποτε από αυτές τις γλώσσες δεν είναι από μόνη της&rsquo;να αντιμετωπίσουμε επαρκώς όλες τις ανάγκες της αίτησής σας? Αλλά σκεφτείτε προσεκτικά πριν ακολουθήσετε αυτήν την προσέγγιση - θα πρέπει να το κάνετε μόνο εάν είναι πιο αποτελεσματικό και πιο αποτελεσματικό από τη χρήση κάθε γλώσσας ξεχωριστά.

συμπέρασμα

Όταν ένα αναπτυξιακό έργο απαιτεί λειτουργικό προγραμματισμό, υπάρχουν πολλές επιλογές διαθέσιμες στην ομάδα ανάπτυξης, από καθαρά λειτουργικές γλώσσες έως γλώσσες πολλαπλών παραλλαγών όπως το C# και το F#. Η καλύτερη επιλογή μεταξύ των καλών ανταγωνιστικών επιλογών δεν είναι πάντα απλή, αλλά ο χρόνος που επενδύεται στην λήψη αυτής της απόφασης θα ανταμειφθεί με βελτιωμένες αποτελεσματικότητες ανάπτυξης και προϊόντα καλύτερης τάξης.