זה עוזר להשלים את התמונה לחיתוך תרחישים עם מערכי תלת מימד ו- 4D.

תצוגה מקדימה: אינדקסים הפוכים

מיקרוסופט מציגה גם את היכולת להשתמש באינדקסים הפוכים, בהם ניתן להשתמש בפרוסות, כתצוגה מקדימה ב- F# 5. כדי להשתמש בו, פשוט מקום תצוגה מקדימה בקובץ הפרויקט שלך.

תן ל- xs = [1..10] // קבל אלמנט 1 מהסוף: xs.[^1] // דרך ישנה להשיג את שני האלמנטים האחרונים LESTTWOOLDSTYLE = XS.[(xs.אורך 2)..] // דרך חדשה לקבל את שני האלמנטים האחרונים LESTTWONEWSTYE = XS.[^1..] lasttwooldstyle = lasttwonewstyle // true 

אתה יכול גם להגדיר את החברים שלך באמצעות סיומת F# סוג כדי להגדיל סוגים אלה כדי לתמוך ב- f# פרוסות ואינדקסים הפוכים. הדוגמה הבאה עושה זאת עם סוג הטווח:

טווח של סוג מערכת פתוח עם חבר SP.GetSlice (startIdx, endidx) = תן s = defaultarg startIdx 0 תן e = defaultarg endidx sp.אורך sp.Slice (S, E - S) חבר SP.GetReverSeindex (_, קיזוז: int) = sp.אורך - אופסט תן ל- SP = [| 1; 2; 3; 4; 5 |].Asspan () sp.[..^2] // [| 1; 2; 3 |] 

F# לסוגים מהותיים יש אינדקסים הפוכים הבנויים. במהדורה עתידית של F#, נתמוך גם באינטרופ מלא עם המערכת.אינדקס ומערכת.טווח, בשלב זה, התכונה כבר לא תהיה בתצוגה מקדימה.

הצעות מחיר לקוד משופרות

F# הצעות מחיר קוד הן תכונה של MetaProgramming המאפשרת לך לתפעל את המבנה של קוד F# ולהעריך אותה בסביבה שבחרת. יכולת זו חיונית לשימוש ב- F# כשפת בניית מודלים למשימות למידת מכונות, בהן מודל ה- AI עשוי לפעול על חומרה שונה, כמו GPU. קטע קריטי שחסר בפאזל זה היה היכולת לייצג נאמנה מידע על אילץ מסוג F#, כמו אלה המשמשים בחשבון גנרי, בציטוט F# כך שמאמר יכול לדעת ליישם את האילוצים האלה בסביבה בה הוא מעריך.

החל מ- F# 5, אילוצים נשמרים כעת בציטוטים של קוד, ומבטלים את היכולת של ספריות מסוימות כמו Diffsharp להשתמש בחלק זה של מערכת F# סוג לטובת היתרון שלה. דרך פשוטה להפגין זו הקוד הבא:

פתח את fsharp.LINQ.RuntimeHelpers תן ל- eval q = leafexpressionConverter .הערכת Quotation Q Let inline necate x = -x // באופן מכריע, 'שליל' יש // החתימה הבאה: // // // val inline negate: // x: ^a -> ^a // כאשר ^a: // (חבר סטטי (~ -): ^a -> ^a) // // אילוץ זה הוא קריטי ל- f## סוגים של ביטחון / . |> הערכה 

השימוש במפעיל אריתמטי מרמז על אילוץ סוג כך שכל הסוגים שהועברו כדי לשלול חייבים לתמוך ב ? מַפעִיל. קוד זה נכשל בזמן ריצה מכיוון שציטוט הקוד לא שומר על מידע אילוץ זה, ולכן הערכתו זורק חריג.

הצעות מחיר לקוד הן הבסיס לכמה עבודה כבדה יותר של מו"פ שנעשתה לשימוש ב- F# כשפה ליצירת מודלים של AI, ולכן היכולת לשמור על מידע אילוץ מסוג זה עוזרת להפוך את F# לשפה משכנעת עבור מתכנתים במרחב זה המבקשים קצת יותר בטיחות בחייהם.

ל- F# 5 יש יסודות גדולים

F# 5 עשוי להתייחס לטוב יותר על תכנות אינטראקטיביות ותכנות אנליטיות, אך בבסיסה, F# 5 עדיין עוסק בקידוד יומיומי ב- F# A Joy. F# 5 כולל מספר תכונות חדשות ששני מפתחי האפליקציות וגם מחברי הספרייה יכולים ליהנות.

תמיכה ב- NameOf

ראשית היא תכונה שמפתחי C# התאהבו: Nameof . מפעיל Nameof לוקח סמל f# כקלט ומייצר מחרוזת בזמן קומפילציה המייצג את הסמל הזה. זה תומך כמעט בכל מבני F#. מפעיל NAMEOF משמש לרוב לצורך רישום אבחון ביישום פועל.

#r "nuget: fsharp.SystemTextJson "מערכת פתוחה.טֶקסט.מערכת פתוחה של JSON.טֶקסט.JSON.מערכת פתוחה של סידורים.זמן ריצה.CompieterServices מודול m = תן ל- f x = nameof x printfn "%s" (m.F 12) printfn "%s" (שם של m) printfn "%s" (שם של m.ו) /// גרסה מפושטת של סוג ה- API של EventStore RocketedEvent = < EventType: string Data: byte[] >/// סוג הבטון שלי: הקלד myevent = | Adata of Int | Bdata של מחרוזת // השתמש ב'- nameof 'במקום במחרוזת מילולית בביטוי ההתאמה תן ל- deserialize (e: recededEdevent): myevent = match e.EventType עם | Nameof Adata -> JSonserializer.Deserialize e.נתונים |> adata | Nameof bdata -> jsonserializer.Deserialize e.נתונים |> bdata | t -> failtwithf "eventtype לא חוקי: %s" t 

מיתרים משולבים

הבא הוא תכונה שנראית בשפות כמו C# ו- JavaScript: מיתרים בינלאומיים. מיתרים בין -פוליטיים מאפשרים לך ליצור אינטרפולציות או חורים במיתר שתוכל למלא בכל ביטוי f#. F# מיתרים משולבים תומכים באינטרפולציות שהוקלדו שם נרדף לאותה פורמט מציין בפורמטים של Sprintf ו- Printf Strings. F# מיתרים משולבים תומכים גם במיתרי ציטוטים משולשים. ממש כמו ב- C#, כל הסמלים באינטרפולציה F# ניתנים לניווט, ניתן לשנות את שמו של וכן הלאה.

// מחרוזת אינטרפולציה בסיסית תן שם = "פיליפ" תן לגיל = 29 תן להודעה = $ "שם :, גיל:" // אינטרפולציה מוקלדת // ' %s' מחייב שהאינטרפולציה תהיה מחרוזת // ' %d' מחייב את האינטרפולציה להיות אינטרפולציה של int got 2 = $ name: %s, %d "// frometim interpolated strings int the string atty inty in inty aty in the in the in aty in aty aty $" "" "" "" "" "" "" "" "" "" "" "" "" שם ":" "," גיל ":" "" 

נוסף. זהו שימוש נישה יותר בתכונה, אך מכיוון שכל אינטרפולציה יכולה להיות ביטוי F# תקף, היא מאפשרת גמישות רבה מאוד.

הצהרות על סוג פתוח

F# תמיד אפשרה לך לפתוח מרחב שמות או מודול לחשיפת המבנים הציבוריים שלו. כעת, עם F# 5, תוכלו לפתוח כל סוג כדי לחשוף מבנים סטטיים כמו שיטות סטטיות, שדות סטטיים, תכונות סטטיות וכן הלאה. ניתן לפתוח גם איחוד ורישומים. אתה יכול גם לפתוח סוג גנרי בהפעלה של סוג ספציפי.

מערכת סוג פתוח.מתמטיקה תן x = דקות (1.0, 2.0) מודול M = סוג du = a | B | C תן לתפקוד מסוים x = x + 1 // לפתוח רק את הסוג בתוך המודול פתוח סוג m.Du printfn "%a" a 

ביטויי חישוב משופרים

ביטויי חישוב הם קבוצה אהובה של תכונות המאפשרות למחברי הספרייה לכתוב קוד אקספרסיבי. עבור אלה שבקימו בתורת הקטגוריות, הם גם הדרך הרשמית לכתוב חישובים מונדיים ומונואידים. F# 5 מרחיב ביטויי חישוב עם שתי תכונות חדשות:

• צורות יישומיות לביטויי חישוב באמצעות LET. וכן! מילות מפתח
• תמיכה נכונה לעומס יתר על פעולות מותאמות אישית

“צורות יישומיות לביטויי חישוב” זה קצת פה. אני אמנע מצלילה לתורת הקטגוריות ובמקום זאת אעבוד דוגמה:

// ראשית, הגדר תוצאה של מודול פונקציה 'מיקוד' = תן ל- zip x1 x2 = התאמה x1, x2 עם | OK X1RES, OK X2RES -> OK (X1RES, X2RES) | שגיאה E, _ -> שגיאה E | _, שגיאה E -> שגיאה e // בשלב הבא, הגדר בונה עם 'mergesources' ו- 'bindreturn' סוג תוצאה builder () = חבר _.Mergesources (T1: תוצאה, T2: תוצאה) = תוצאה.חבר zip t1 T2 _.Bindreturn (x: תוצאה, f) = תוצאה.MAP F X LET RELUTIO! תן RES1: תוצאה = תוצאה < let! a = r1 and! b = r2 and! c = r3 return a + b - c >להתאים Res1 עם | אישור x -> printfn " %s הוא: %d" (שם של res1) x | שגיאה e -> printfn " %s הוא: %s" (שם של res1) ה 

לפני F# 5, כל אחד מאלה ו! מילות מפתח היו נותנות! מילות מפתח. ה! מילת המפתח שונה בכך שהביטוי שעוקב אחריו חייב להיות עצמאי במאה אחוז. זה לא יכול להיות תלוי בתוצאה של LET קודם! -ערך כבול. המשמעות היא שקוד כמו להלן לא מצליח להרכיב:

תן RES1: תוצאה = תוצאה < let! a = r1 and! b = r2 a // try to pass 'a' and! c = r3 b // try to pass 'b' return a + b - c >

אז מדוע שנגרום לקוד הזה לא יצליח להרכיב? כמה סיבות. ראשית, היא אוכפת עצמאות חישובית בזמן קומפילציה. שנית, זה אכן קונה ביצועים קטנים בזמן ריצה מכיוון שהוא מאפשר למהדר לבנות את גרף השיחה באופן סטטיטי. שלישית, מכיוון שכל חישוב הוא עצמאי, הם יכולים להיות מבוצעים במקביל על ידי כל סביבה בה הם פועלים. לבסוף, אם חישוב נכשל, למשל בדוגמה הקודמת שבה ניתן להחזיר ערך שגיאה במקום ערך בסדר, כל העניין אינו קצר מעגל על ​​כישלון זה. טפסים יישומיים “לאסוף” כל הערכים שהתקבלו ומאפשרים לכל חישוב לרוץ לפני הגמר. אם היית מחליף כל אחד ו! עם LET! , כל מה שהחזיר שגיאה קצרה מעגלית מהפונקציה. התנהגות שונה זו מאפשרת למחברים ומשתמשים בספריה לבחור את ההתנהגות הנכונה על סמך התרחיש שלהם.

אם זה נשמע כאילו זה קצת קונספט כבד, זה בסדר! חישובים יישומיים הם קצת מושג מתקדם מנקודת מבט של מחבר הספרייה, אך הם כלי רב עוצמה להפשטה. כמשתמש בהם, אינך צריך לדעת את כל הפרטים הקטנים כיצד הם עובדים; אתה יכול פשוט לדעת שכל חישוב בביטוי חישוב מובטח להפעיל ללא תלות באחרים.

שיפור נוסף לביטויי חישוב הוא היכולת לתמוך כראוי בעומס יתר על פעולות בהתאמה אישית עם אותו שם מילות מפתח, תמיכה בטיעונים אופציונליים ותמיכה במערכת.טיעוני paramarray. פעולה מותאמת אישית היא דרך עבור מחבר הספרייה לציין מילת מפתח מיוחדת המייצגת פעולה מסוג משלהם שיכולה לקרות בביטוי חישוב. תכונה זו משמשת רבות במסגרות כמו סטורן להגדרת DSL אקספרסיבית לבניית אפליקציות אינטרנט. החל מ- F# 5, מחברי רכיבים כמו שבתאי יכולים להעמיס על פעולותיהם המותאמות אישית ללא כל אזהרות, כפי שמוצג ב רישום 1.

רישום 1: ביטויי חישוב יכולים להעמיס על פעולות בהתאמה אישית

הקלד inputKind = | טקסט של מציין מקום: אפשרות מחרוזת | סיסמת מציין מקום: אפשרות מחרוזת סוג inputOptions = < Label: string option Kind: InputKind Validators: (string ->BOOL) מערך> סוג InputBuilder () = חבר t.תשואה (_) = < Label = None Kind = Text None Validators = [||] >[] חבר זה.טקסט (io,?מציין מקום) = < io with Kind = Text placeholder >[] חבר זה.סיסמא (IO,?מציין מקום) = < io with Kind = Password placeholder >[] חבר זה.תווית (io, Label) = < io with Label = Some label >[] חבר זה.מאמת (IO, [] תוקפים) = < io with Validators = validators >תן לקלט = inputbuilder () תן שם = קלט < label "Name" text with_validators (String.IsNullOrWhiteSpace >> לא)> תן לדוא"ל = קלט < label "Email" text "Your email" with_validators (String.IsNullOrWhiteSpace >> לא) (כיף s -> 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# מחברי ספרייה יכולים לעשות בהמשך.

יישומי ממשק במייציות גנריות שונות

החל מ- F# 5, כעת תוכל ליישם את אותו ממשק במיידיות גנריות שונות. תכונה זו פותחה בשותפות עם לוקאס רייגר, תורם של קוד פתוח F#.

סוג IA = חבר מופשט GET: יחידה -> ?T הקלד את myclass () = ממשק ia עם חבר x.Get () = ממשק 1 ia עם חבר x.Get () = "שלום" תן mc = myclass () תן asint = mc:> ia let asstring = mc:> ia asint.קבל () // 1 asstring.קבל () // "שלום" 

יותר .שיפורים באינטרופ נטו

.Net היא פלטפורמה מתפתחת, עם מושגים חדשים שהוצגו כל מהדורה, וכך, יותר הזדמנויות להשתלב. ממשקים פנימה .NET יכול כעת לציין יישומי ברירת מחדל לשיטות ומאפיינים. F# 5 מאפשר לך לצרוך ממשקים אלה ישירות. שקול את קוד ה- C# הבא:

שימוש במערכת; מרחב השמות csharplibrary < public interface MyDim < public int Z =>0; >> 

ניתן לצרוך ממשק זה ישירות ב- F#:

פתח את CSHARP // צור ביטוי אובייקט ליישום הממשק LET MD = < new MyDim >printfn $ "Dim מ- C#:" 

מושג נוסף ב .נטו שמקבל תשומת לב רבה יותר היא סוגי ערכים ניתנים לביטול (נקראו בעבר סוגים בבלים). בתחילה נוצרו כדי לייצג טוב יותר את סוגי נתוני SQL, הם גם יסודיים לספריות מניפולציה לנתוני ליבה כמו הפשטת מסגרת הנתונים במיקרוסופט.נתונים.אָנָלִיזָה . כדי להקל מעט על התאמה עם ספריות אלה, אתה מיישם כלל חדש שמכוון לסוג לשיטות שיחות והקצאת ערכים למאפיינים שהם סוג ערך הניתן לבטל. שקול את המדגם הבא באמצעות חבילה זו עם הנחיית הפניה לחבילה:

#R "Nuget: Microsoft.נתונים.ניתוח "פתוח מערכת פתוח מיקרוסופט.נתונים.ניתוח תן ל- DateTimes = "DateTimes" |> PrimitiveTaframeColumn // להלן נכשל בכדי להרכיב את Let Date = DateTime.Parse ("2019/01/01") DateTimes.הוסף (תאריך) // הקודם שווה כעת ל: תן לתאריך = DateTime.PARSE ("2019/01/01") תן לנתונים = NULLABLE (תאריך) DateTimes.הוסף (נתונים) 

דוגמאות אלה המשמשות לדרוש שתבנה במפורש סוג ערך בולט עם קונסטרוקטור מסוג בטל כפי שהדוגמה מראה.

הופעה טובה יותר

צוות מיקרוסופט בילה את השנה האחרונה בשיפור ביצועי המהדר של F# מבחינת התפוקה והביצועים של כלים ב- IDEs כמו Visual Studio. שיפורי הביצועים הללו התגלגלו בהדרגה ולא כחלק משחרור אחד גדול. סכום העבודה הזו שמגיעה לשיאה ב- F# 5 יכולה לעשות את ההבדל לתכנות F# יומיומיות. כדוגמה, ריכזתי את אותו בסיס קוד ? פרויקט הליבה ב- fsharplus, פרויקט שמדגיש באופן ידוע לשמצה את מהדר F# ? שלוש פעמים. פעם עבור F# 5, פעם אחת עבור ה- F# 4 האחרון.7 עם .Core Net, ופעם אחת עבור ה- F# 4 האחרון.5 בתוך .גרעין נטו, כפי שמוצג ב שולחן 1.

התוצאות ב שולחן 1 בוא מהפעלת Dotnet Build /CLP: PerformationsUnnary מקו הפקודה ומסתכל על הזמן הכולל שהוקדש למשימת FSC, שהיא המהדר F#. התוצאות עשויות להשתנות במחשב שלך בהתאם לדברים כמו עדיפות בתהליך או לעבודת רקע, אך עליך לראות בערך את אותן ירידות בזמני ההרכבה.

ביצועי IDE מושפעים בדרך כלל משימוש בזיכרון מכיוון שאיידס, כמו Visual Studio, מארחים מהדר בשירות שפה כתהליך ארוך חיים. כמו בתהליכי שרת אחרים, כך פחות זיכרון אתה משתמש, כך זמן ה- GC פחות מבלה בניקיון זיכרון ישן וככל שניתן להקדיש זמן לעיבוד מידע שימושי. התמקדנו בשני תחומים עיקריים:

• שימוש בקבצים ממופים זיכרון כדי לגב מטא נתונים שנקראו מהמהדר
• ארכיטקטוריון מחדש של פעולות שמוצמות סמלים על פני פיתרון, כמו למצוא את כל הפניות ושינוי שם

התוצאה היא פחות שימוש בזיכרון לפתרונות גדולים יותר בעת שימוש בתכונות IDE. איור 5 מציג דוגמה לשימוש בזיכרון בעת ​​הפעלת הפניות למצוא את סוג המחרוזת במזויף, בסיס קוד גדול מאוד של קוד פתוח, לפני השינויים שביצענו.

פעולה זו אורכת גם דקה ו -11 שניות להשלמה כאשר היא מפעילה לראשונה.

עם F# 5 וכלי ה- F# המעודכנים עבור Visual Studio, אותה פעולה אורכת 43 שניות להשלים ומשתמשת יותר מ -500MB פחות זיכרון, כפי שמוצג ב איור 6.

הדוגמה עם תוצאות המוצגות ב איור 5 וכן איור 6 הוא קיצוני, מכיוון שרוב המפתחים לא מחפשים שימושים מסוג בסיס כמו מחרוזת בבסיס קוד גדול מאוד, אבל זה מראה כמה ביצועים טובים יותר כשאתה משתמש ב- F# 5 והכלי האחרון ל- F# לעומת רק לפני שנה.

ביצועים הם משהו שעובד עליו כל הזמן, ושיפורים מגיעים לרוב מתורמי הקוד הפתוח שלנו. חלקם כוללים את סטפן פורקמן, יוג'ין אודוחינוק, צ'ט הוסט, סול רניסון, הבל בראקסמה, אייזק אברהם ועוד. כל מהדורה כוללת יצירה מדהימה של תורמי קוד פתוח; אנו מודים לנצח על עבודתם.

המסע F# המתמשך ואיך להסתבך

צוות Microsoft F# נרגש מאוד לשחרר את F# 5 השנה ואנחנו מקווים שתאהבו את זה באותה מידה. F# 5 מייצג את תחילתו של מסע חדש עבורנו. במבט קדימה, אנו הולכים לשפר ללא הרף חוויות אינטראקטיביות כדי להפוך את F# לבחירה הטובה ביותר עבור מחברות וכלים אינטראקטיביים אחרים. אנו הולכים להעמיק בעיצוב השפה ולהמשיך לתמוך בספריות כמו Diffsharp כדי להפוך את F# לבחירה משכנעת למידת מכונה. וכמו תמיד, אנו הולכים להשתפר על יסודות F# מהדר F# ולשלב תכונות שפה שכולם יכולים ליהנות מהם.

נשמח לראות אותך גם לרכיבה. 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# פועל בהרכבת האינטרנט: https: // fsbolero.io/

קרן התוכנה F# מארחת גם קהילת רפיון גדולה, בנוסף להיותה נקודה מרכזית עבור תת-קהילות שונות לשתף מידע זה עם זה. זה בחינם להצטרף, אז המשך לאתר כאן למידע נוסף: http: // קרן.fsharp.org/הצטרף

רוצה לומר איפה F# הולך הלאה ואיך זה עושה את זה? בוא הצטרף אלינו. נשמח לעבוד יחד.

מחברות יופיטר

מחברות יופיטר הן כלי תכנות אינטראקטיבי המאפשר לך לערבב סימון וקוד במסמך. ניתן לבצע את הקוד במחברת, לעתים קרובות כדי לייצר נתונים או תרשימים מובנים שעוברים יד ביד עם הסבר.

מחברות Jupyter התחילו בתור Ipython, כלי תכנות אינטראקטיבי לתוכניות Python. זה גדל לתמוך בשפות רבות ושונות וכעת הוא אחד הכלים העיקריים המשמשים מדעני נתונים בעבודתם. זה משמש גם ככלי חינוכי.

טבלה 1: זמני קומפילציה עבור fsharpplus.DLL על פני גרסאות F# האחרונות

F# שפת תכנות: היסטוריה, יתרונות ואפשרויות עתידיות

מפתחים נסקים עשויים לטעות בהגנת השם כ- f ‘בְּלִיל’ אבל זה ירוויח כמה עיניים זלזול מהאנשים המיומנים במפתח’S קהילה. F חד (מכיוון שה- # מבוטא כחרפ. שפת התכנות הרב-פרדיגמה כוללת תכנות פונקציונלית, הכרחית ומכוונת אובייקטים

כל שפת תכנות יכולה להיכנס לאחת משתי הקטגוריות; הוקלד מאוד ומוקלד בצורה חלשה.

לשפות שהוקלדו מאוד יש תקנות עקשניות מאוד בזמן קומפילציה, ומשמעו כי יש סיכוי גבוה יותר שטעויות וחריגים. רוב התקנות הללו משפיעות על ערכי החזרה, הקצאות משתנות ועל שיחות פונקציות.

בעוד ששפה מוקלדת חלשה היא הפוכה ויש לה כללי הקלדה רופפים שיכולים לבטל תוצאות בלתי צפויות או עלולים לגרום להמרה מסוג מרומז בזמן ריצה.

רב-פרדיגמה מתייחסת לתמיכה של יותר מפרדיגמת תכנות אחת כדי לאפשר למתכנתים לבחור את סגנון התכנות המתאים ביותר ואת מבני השפה הנלווים לפרויקט נתון.

לעתים קרובות הוא משמש כ- CLI חוצה פלטפורמות (תשתית שפה נפוצה) ויכול גם ליצור קוד JavaScript ו- GPU (יחידת עיבוד גרפי).

זה מפותח על ידי F# Software Foundation ו- Microsoft יחד עם תורמים פתוחים אחרים.

היסטוריה קצרה

F# לראשונה נערך בשנת 2005 כאשר הוא פותח על ידי Microsoft Research. בתחילה, זה היה א .נטו (מבוטא כ- DOT NET) יישום OCAML מכיוון שהוא שילב את הכוח והתחביר של השפה הפונקציונלית עם אלפי פונקציות ספריות זמינות עם .שפות נטו.

מאז 2005, F# עברה שינויים רבים נדרשים והמפתחים עשו גרסאות שונות שהפכו את זה לטובות יותר מהראשון. ההשקה תחת רישיון Apache, הפכה את שפת התכנות למקור פתוח שמשמעותו שניתן לשנות אותה, להפיץ אותה ולהשתמש בה מבלי לשלם למפתחים המקוריים.

הגרסה הראשונה שהושקה בשנת 2005 הייתה תואמת רק ל- Windows ופרסה א .רשת 1.0 עד 3.5 זמן ריצה. בסיס הפלטפורמה הצר היה החולשה הגדולה ביותר של גרסה זו. הנושא טופל בגרסה הבאה שפותחה עם תוספת של OS X וגם לינוקס לפלטפורמות הנתמכות בגרסה 2.0 שהושק בשנת 2010.
בשנת 2012, F# ראה את הוספת JavaScript ו- GPU בפלטפורמות הנתמכות. הגרסה האחרונה הושקה בשנת 2015 שהייתה 4.0.

העתיד של f#

אנשים רבים טוענים ש- F# היא אחת משפות התכנות הלא פופולריות, המוערכות והמתאמות ביותר. אבל יש צד אחר לסיפור. על פי StackOverflow. F# נבחר לשפה הקשורה למשכורת המשלמת הגבוהה ביותר ברחבי העולם.

באותו סקר מראה ש- f# לא’לא מופיעים ב -25 שפות התכנות המובילות המשמשות ברחבי העולם. השפה נשארת על השוליים למרות שיש לה קהילה פעילה באמת.

אבל מדוע מפתחים אוהבים לעבוד עם f# אם זה’s כל כך לא פופולרי? F# נוצר ומוחזק על ידי דון סימה, היה גמיש יחסית לחלק מהסבירות יתר על המידה שאימצו שפות FP דומות כמו סקאלה. התנגדות זו שומרת על נגישות למפתחים מהעולם החיצון שעשויים להיות מעוניינים להתמודד עם תכנות פונקציונליות.

F# שימש מצוין בכל הנוגע לפיתוח מונע נתונים ומונע תחום. עכשיו ניתן להרכיב אותו גם ל- JavaScript שהוא העולם’השפות הפופולריות ביותר. עם קישור זה מאובטח, יש לו גם גישה ל- JavaScript’ספריות נרחבות ובסיס מכשירים.

F# הטביע את חותמו בכל הנוגע לבינה מלאכותית, למידת מכונות וניתוח נתונים נלווים. זו הייתה עצם המטרה של יצירת F#. בשל הסולם העצום וההשפעה הצפויה, הבינה המלאכותית תהיה על מערכות אקולוגיות ושפה טכנולוגיות באופן כללי, בעלת שפה כל כך מתאימה למקומות פיתוח בהם עמדה חזקה לצמוח במהירות ואף לאתגר שפות פופולריות כמו JavaScript ו- Python בעתיד.

מה עוצר f#’צמיחה?

למרות שזה נראה כמו עובדה קשה לעיכול, האשמה בכך מיוחסת בעיקר ליוצריה, שהיא מיקרוסופט. הם הגבילו את הפופולריות של f# לתת ל- C# לפרוח שם. מיקרוסופט הפכה את F# נחותה מ- C#.

יש לזה תנועה מחזורית. מעט משרות קיימות עבור F# מכיוון שיש מעט מפתחי F# בחוץ ויש שם פחות מפתחי F# מכיוון שיש פחות עבודות F#. אך לאט אך בטוח, מגמה זו משתנה.

מטוס סילון.COM הייתה החברה הגדולה הראשונה שאימצה את השימוש ב- F#. בהמשך, קגגל וחברות פיננסיות וביטוח רבות עקבו גם כן.

המפתחים של F# חסרים ניסיונות להפוך אותו לפופולרי יותר ותכונות כשפה רב-פרדיגמה המשמשת מאוד ב- AI, הדבר הטוב ביותר לעשות הוא להתמקד ביתרונות הליבה של F# שהם זמני ריצה קצרים יותר, פחות באגים ופרודוקטיביות גבוהה יותר. אם הוא מקודם על ידי הדגשת תכונות אלה, זה עשוי לעזור f# לטפס על סולם הפופולריות מהר יותר מבעבר.

האם f# באמת מחזיק כל יתרון על פני c#?

כבר מכיר את C#? ואז למד כיצד לתכנת את משחק הפריצה שלך באמצעות C#.

• F# הופך משימות תכנות נפוצות רבות לפשוטות יותר. זה כרוך בדברים כמו יצירה ושימוש בהגדרות מסוג מורכב, ביצוע עיבוד רשימות, מכונות מצב, שוויון והשוואה, ועוד ועוד.
• נטולת סמיקונים, סוגריים מתולתלים וכאלה, ב- F# אתה כמעט אף פעם לא צריך לציין את סוג האובייקט בגלל נוכחות של מערכת הסקה מסוג רב עוצמה. זה לוקח גם פחות שורות קודים כדי לפתור גם את הבעיה
• F# היא שפה פונקציונלית, אך היא אכן תומכת בסגנונות אחרים שאינם’t טהור לחלוטין, מה שמקל על הקלה הרבה יותר עם התחום הלא-טהור של מסדי נתונים, אתרים וכן הלאה. בפרט, F# מעוצב כשפה היברידית/OO פונקציונלית, כך שהיא מסוגלת לעשות הכל כ- c#. למרות ש- f# משתלב בצורה חלקה עם .מערכת אקולוגית נטו המאפשרת לך לגשת לכל הצדדים השלישיים .כלים וספריות נטו.
• F# הוא חלק מ- Visual Studio המאפשר לך להשיג עורך טוב עם תמיכה אינטליזנס, ניפוי באגים ותוספים רבים לבדיקות יחידות, בקרת מקור ומשימות פיתוח אחרות.

F# עתיד

דומה לאסינק < >לחסום אך לוכד את התוצאה לצריכה עתידית. מבנה זה יכול להיות שימושי מאוד לביצוע פעולות חוזרות תוצאות מרובות במקביל כאשר התוצאות אינן נחוצות מייד. לדוגמה, ביצוע מספר פעולות קריאה/טרנספורמציה או אוכלוסייה מראש של מטמון עם ערכים מחושבים שעדיין יהיה. הספרייה המקבילה של מיקרוסופט ב .נטו 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: 

לִפְתוֹחַ מערכת לִפְתוֹחַ מערכת.רכיב מודל לִפְתוֹחַ מערכת.הַשׁחָלָה /// מבצע חישוב בעובד רקע ומסנכרן על החזרת התוצאה. ה /// החישוב מופעל מייד וקורא לחסימות 'ערך' עד שהתוצאה מוכנה. סוּג עתיד't>((ג : יחידה -> 't) = /// תוצאת החישוב ביציאה רגילה. לתת מִשְׁתַנֶה תוֹצָאָה :'t אוֹפְּצִיָה = אף אחד /// תוצאה אם ​​נזרק חריג. לתת מִשְׁתַנֶה שלוחה : יוצא מן הכלל אוֹפְּצִיָה = אף אחד לתת סינכרוט = חָדָשׁ לְהִתְנַגֵד() /// אובייקט דופק משמש לחכות עד שהתוצאה תהיה מוכנה. משתמשים ב- Ensurepulse () כך שאנחנו /// לא צריך ליצור את האובייקט אם התוצאה נעשית לפני שהיא נחוצה. לתת מִשְׁתַנֶה דוֹפֶק : ManualResetEvent = ריק לתת Ensurepulse() = לנעול סינכרוט ((כֵּיף () -> התאמה דוֹפֶק עם | ריק -> דוֹפֶק  חָדָשׁ ManualResetEvent((שֶׁקֶר); | _ -> () דוֹפֶק) /// אזהרה: התקשרו ברגע שכבר נערך מנעול בסינקרוט. פולסים את הודעת ההמתנה. בטוח אם /// נקרא לאחר 'דופק' נוצר אך לפני שמתקרא Waitone. לתת NotifyWaiters() = אם דוֹפֶק <> ריק לאחר מכן דוֹפֶק.מַעֲרֶכֶת() |> להתעלם לתת עֲבוֹדָה = חָדָשׁ עובד רקע() /// ב- runworkerasync (), הפעל פונקציה מוגדרת ותוצאת חנות. כל החריגים חייבים להיות /// לכוד. לַעֲשׂוֹת עֲבוֹדָה.תעבוד.לְהוֹסִיף(( כֵּיף args -> לְנַסוֹת תוֹצָאָה  כמה(( ג()) עם ה -> שלוחה  כמה ה לנעול סינכרוט (( כֵּיף () -> NotifyWaiters())) /// התחל מייד/ אוטומטית. לַעֲשׂוֹת עֲבוֹדָה.Runworkerasync() /// מחזיר את ערך החישוב, חוסם אם התוצאה עדיין לא מוכנה. חבר t.ערך =<
/span> // אם זמין, נוכל להחזיר אותו מייד. התאמה תוֹצָאָה עם | כמה איקס -> איקס | אף אחד מתי שלוחה.הוא חלק -> הַעֲלָאָה ((אוֹפְּצִיָה.לקבל שלוחה) | אף אחד -> לתת עמ ' = Ensurepulse() // בדוק שוב במקרה שזה ישתנה בזמן שקיבלנו את אובייקט ההמתנה. התאמה תוֹצָאָה עם | כמה איקס -> איקס | אף אחד -> // מנעול נטול זה בסדר כי אם הדופק.שיטה להגדיר () נקראת בין כאשר אנחנו // בדק את 'התוצאה' והתקשר כאן ל- Waitone, Waitone תחזור מייד. עמ '.ממתין((1000000000) |> להתעלם התאמה תוֹצָאָה עם | כמה איקס -> איקס | אף אחד -> אם שלוחה.הוא חלק לאחר מכן הַעֲלָאָה ((אוֹפְּצִיָה.לקבל שלוחה) אַחֵר כישלון "חישוב עתידי נכשל." /// חוזר נכון אם החישוב מסתיים, שקר אם לא. חבר t.הושלם = התאמה תוֹצָאָה עם | כמה איקס -> נָכוֹן | אף אחד מתי אוֹפְּצִיָה.הוא חלק שלוחה -> נָכוֹן | אף אחד -> שֶׁקֶר 

מערכת מרחב השמות

מערכת מרחב השמות.רכיב מודל

מערכת מרחב השמות.הַשׁחָלָה

פריטים מרובים
הקלד עתיד =
חדש: f: (יחידה -> 't) -> עתיד
חבר isComplete: bool
ערך חבר: 't

שם מלא: סקריפט.עתיד

מבצע חישוב בעובד רקע ומסנכרן על החזרת התוצאה. ה
החישוב מתחיל מייד ומתקשר לחסימות 'ערך' עד שהתוצאה מוכנה.

Val f: (יחידה -> 't)

הקלד יחידה = יחידה

שם מלא: מיקרוסופט.Fsharp.הליבה.יחידה

תוצאה ניתנת לשינוי: 'אפשרות T

תוצאה של החישוב ביציאה רגילה.

הקלד אפשרות = אפשרות

שם מלא: מיקרוסופט.Fsharp.הליבה.אוֹפְּצִיָה

אפשרות מקרה של איחוד.אף אחד: אפשרות

EXT ניתן לשתול: אפשרות חריגה

תוצאה אם ​​נזרק חריג.

פריטים מרובים
הקלד חריג =
חדש: יחידה -> חריג + 2 עומסי יתר
נתוני חבר: Idicationary
חבר getBaseexception: יחידה -> חריג
חבר getObjectData: מידע: SerializationInfo * הקשר: StreamingContext -> יחידה
חבר getType: יחידה -> סוג
חבר Helplink: מחרוזת עם get, set
חבר Innerexception: חריג
הודעת חבר: מחרוזת
מקור חבר: מחרוזת עם get, set
חבר StackTrace: מחרוזת
.

שם מלא: מערכת.יוצא מן הכלל

--------------------
חריג (): יחידה
חריג (הודעה: מחרוזת): יחידה
חריג (הודעה: מחרוזת, innerexcepte

סינכרוט VAL: אובייקט

פריטים מרובים
הקלד אובייקט =
חדש: יחידה -> OBJ
חבר שווה: OBJ: OBJ -> BOOL
חבר gethashcode: יחידה -> int
חבר getType: יחידה -> סוג
ToString של חבר: יחידה -> מחרוזת
חבר סטטי שווה: Obja: OBJ * OBJB: OBJ -> BOOL
חבר סטטי של חבר סטטי: Obja: OBJ * OBJB: OBJ -> BOOL

שם מלא: מערכת.לְהִתְנַגֵד

דופק הניתן לשינוי Val: ManuareResetevent

אובייקט דופק משמש לחכות עד שהתוצאה תהיה מוכנה. משתמשים ב- Ensurepulse () כך שאנחנו
לא צריך ליצור את האובייקט אם התוצאה נעשית לפני שהיא נחוצה.

פריטים מרובים
הקלד ManualResetEvent =
ירש את EventWaithandle
חדש: ראשוני: bool -> manualResetevent

שם מלא: מערכת.הַשׁחָלָה.ManualResetEvent

--------------------
ManualResetEvent (ראשוני: bool): יחידה

val enturepulse: (יחידה -> manualResetEvent)

נעילת VAL: LockObject: 'נעילה -> פעולה: (יחידה ->' t) -> 't (דורש סוג התייחסות)

שם מלא: מיקרוסופט.Fsharp.הליבה.מפעילים.לנעול

Val NotifyWaiters: (יחידה -> יחידה)

אזהרה: התקשרו ברגע שכבר נערך מנעול בסינכרוט. פולסים את הודעת ההמתנה. בטוח אם
נקרא לאחר 'דופק' נוצר אך לפני שמכונה Waitone.

EventWaithandle.סט (): בול

Val להתעלם: ערך: 't -> יחידה

שם מלא: מיקרוסופט.Fsharp.הליבה.מפעילים.להתעלם

עבודת VAL: עובד רקע

פריטים מרובים
הקלד רקע רקע =
רכיב לרשת
חדש: יחידה -> עובד רקע
חבר CallingAsync: יחידה -> יחידה
חבר ביטול החברים: Bool
חבר איסבוסי: בול
דו"ח חבר: אחוזת אחוז: int -> יחידה + עומס יתר
חבר RunworkerAsync: יחידה -> יחידה + 1 עומס יתר
חבר WorkerReportSprogress: bool עם get, set
עובדים עובדים
Dowork Event: doworkeventhandler
אירוע התקדמות: ProgressChangedEventHandler
.

שם מלא: מערכת.רכיב מודל.עובד רקע

אירוע רקע אירוע.Dowork: ievent

חבר iobservable.הוסף: התקשרות חוזרת 🙁 'T -> יחידה) -> יחידה

val args: doworkeventargs

אפשרות מקרה של איחוד.כמה: ערך: 't -> אפשרות

Val E: EXN

עובד רקע.RunworkerAsync (): יחידה
עובד רקע.RunworkerAsync (טיעון: OBJ): יחידה

Val T: עתיד

עתיד חבר.ערך: 't

שם מלא: סקריפט.עתיד '1.ערך

ב- RunworkerAsync (), הפעל פונקציה מוגדרת ותוצאת חנות. כל החריגים חייבים להיות
לכוד.
התחל מייד / אוטומטית.
מחזיר את ערך החישוב, חוסם אם התוצאה עדיין לא מוכנה.

אפשרות נכס.ISSOME: BOOL

val laise: exn: חריג -> 't

שם מלא: מיקרוסופט.Fsharp.הליבה.מפעילים.הַעֲלָאָה

val get: אפשרות: 't option ->' t

שם מלא: מיקרוסופט.Fsharp.הליבה.אוֹפְּצִיָה.לקבל

Val P: ManualResetevent

להמתין.Waitone (): Bool
להמתין.Waitone (פסק זמן: TimeSpan): Bool
להמתין.Waitone (אלפיות השנייה
להמתין.Waitone (פסק זמן: TimeSpan, exitContext: bool): bool
להמתין.Waitone (אלפיות שניות: int, exitContext: bool): bool

val failwith: הודעה: מחרוזת -> 't

שם מלא: מיקרוסופט.Fsharp.הליבה.מפעילים.כישלון

עתיד חבר.IsComplete: Bool

שם מלא: סקריפט.עתיד '1.הושלם

חוזר נכון אם החישוב מסתיים, שקר אם לא.

VAL ISSOME: אפשרות: 'אפשרות T -> BOOL

שם מלא: מיקרוסופט.Fsharp.הליבה.אוֹפְּצִיָה.הוא חלק

העתק קישור מקור מקור תצוגה גולמית קוד בדיקה גרסה חדשה

עוד מידע

בניין פונקציונלי .יישומים נטו: מדריך לבחירה בין F# לעומת C#

היעילות היא הכל בעולם פיתוח היישומים. מפתחים וארגונים שיכולים לגרום למוצרים לשווק מהר יותר ולספק רעננים מהירים יותר תמיד יהיה יתרון על התחרות.

אז כולם תמיד מחפשים דרכים לצמצם את זמן הפיתוח, זמן בילוי באגים ובדיקות, וזמן לדחוף את הסתיימו לשחרר ללקוחות.

תכנות פונקציונליות היו בשימוש נפוץ לפני עשרות שנים אך איבד את הקרקע במהירות לשפות תכנות מונחות עצמים, שהפכו במהרה לתקן דה-פקטו.

תוכן ממומן קשור

נותן חסות קשור

קוד, פרוס וקנה מידה של ג'אווה בדרך שלך.
Microsoft Azure תומכת בעומס העבודה שלך בבחירות בשפע, בין אם אתה עובד על אפליקציית Java, שרת אפליקציות או מסגרת. למד עוד.

אך בשנים האחרונות חלה תחיית עניין בתכנות פונקציונאלית כדרך לשפר את יעילות הפיתוח ולבנות יישומים יציבים וחזקים יותר.

C# ו- F# הם שפות עם בסיסי משתמשים הולכים וגדלים המתקרבים לתכנות פונקציונאלית בדרכים שונות ביסודו: C# כתוספת לפרדיגמה חיובית מובנית ו- F# כפרדיגמה העיקרית שלה.

מאמר זה חוקר איזו מהשפות הללו עושה את התפקיד הטוב ביותר עבור מפתחים המעוניינים להציב תכנות פונקציונליות עבור הצוותים והפרויקטים שלהם.

הוויכוח על תכנות מונחה אובייקטים פונקציונלית לעומת אובייקטים

כדי להבין את הוויכוח, עלינו להתחיל ברמה מעט גבוהה יותר עם ההבדל בין פרדיגמות תכנות הכרוכות להצהרתי.

• תכנות חיוביות: גישת תכנות מבוססת תהליכים, בה מפתחים מציין כיצד להשיג תוצאות שלב אחר שלב. תכנות חיוביות מתמקדות בשינויי מדינת התוכנית ובמדינה. שפות תכנות מונחות עצמים כמו Java ו- C ++ בדרך כלל עוקבות אחר הפרדיגמה החובה.
• תכנות הצהרתית: גישת תכנות מוכוונת תוצאות, בה מפתחים מציין את סוגי התוצאות הרצויות. תכנות הצהרתית היא חסרת מדינה וצו ביצוע אגנוסטי. שפות תכנות פונקציונליות כמו LISP, Python, Haskell ו- F# עוקבות אחר פרדיגמת התכנות ההצהרתית.

אבל זה פשט יתר לנסות ולחלק בצורה מסודרת את כל שפות התכנות הקיימות לקטגוריות אלה, שכן מספר שפות מציעות היבטים של כל אחת מהן. אלה שפות היברידיות או מרובות פרדיגמה.

לדוגמה, למרות ש- Java ו- C ++ באופן מסורתי נופלים בסיווג החישוב, יש להם גם היבטים פונקציונליים. כך גם ב- C#. באופן דומה, למרות ש- F# נחשב לשפה פונקציונלית, יש לה גם יכולות חיוביות.

התבונן ברשימת עשרת השפות המובילות שמשתמשים במפתחים. תוכלו לראות שהם מקיפים בעיקר שפות היברידיות, כאשר חלקם מתמקדים בציווי ואחרים פונקציונליים יותר דומיננטיים יותר.

JavaScript, שהחזיק את המקום הראשון בסקר זה מזה עשור, הוא שפה רב-פרדיגמה, המציעה גם תכונות חיוניות, מונחות אובייקטים ותכונות פונקציונליות.

בהתחשב במגוון האימוץ, מועיל לשקול את היתרונות השונים שכל פרדיגמה מציגה ואת מקרי השימוש השונים בהם כל אחד מצטיין.

תכנות הכרחיות: היתרונות והשימוש במקרים

בין היתרונות העיקריים של הפרדיגמה הכרחית הוא שקוד שנכתב באמצעותו בדרך כלל מובן בקלות ויכול להיות קל לקריאה. יתר על כן, בהתחשב בתיאורי זרימת העבודה המוקפדים שתכנות חיונית דורשת, אפילו מפתחים מתחילים קלים לעקוב.

אבל רמת התכנות הכוויית הפירוט דורשת מגיעה גם עם חסרונות. לדוגמה, ביישומים מורכבים יותר, הקוד יכול להתנפח במהירות. ככל שגודל הקוד גדל, קלות הקריאה וההבנה בדיוק נופלת במהירות.

יתר על כן, ככל שהקוד מתרחב, הפוטנציאל לבאגים ושגיאות עולה. לפיכך, מפתחים העובדים עם שפות חיוניות לעתים קרובות מוצאים עצמם מבלים זמן רב באגים ובדיקות, ומעכבים את שחרורי המוצר.

עם זאת, תכנות חיוביות נשארות פופולריות להפליא ויש לה מגוון רחב של מקרי שימוש. יישומים מסורתיים לתכנות הכרחית כוללים:

• היפר -טקסט והיפרמדיה
• מערכות ניהול מסדי נתונים של אובייקטים (ODBMS)
• מערכות שרת לקוח
• מערכות בזמן אמת
• בינה מלאכותית, למידת מכונות ורשתות עצביות
• אוטומציה

תכנות פונקציונליות: יתרונות ושימוש במקרים

היתרונות של תכנות פונקציונלית נוחתת יותר בצד היעילות של המשוואה. קוד פונקציונלי, בעוד שהוא פחות קל לקריאה ולהבנה במבט ראשון, נוטה להיות קרוב יותר ללא באגים (i.ה., אין תופעות לוואי לשינויי מדינה), מה שמקטין את זמן המפתח לבילוי באגים ובדיקה.

פחות באגים גם נוהגים ליישומים מאובטחים יותר, ומגבילים את משטח ההתקפה עבור פושעי רשת כדי להפחית את הסיכויים להתקפות כופר, תוכנות זדוניות או זריקות SQL.

תכנות פונקציונלית טובה יותר גם הן בעיבוד מקביל והן בהערכה עצלה. בנוסף, קוד פונקציונלי הוא מודולרי ושימוש חוזר יותר, ומפחית את הצורך בקוד מיותר. קל יותר לתחזק את מערך הקוד הקטן יותר ויכול להיות בעל ביצועים גבוהים יותר. עם זאת, קוד פונקציונלי יכול להיות אינטנסיבי בזיכרון, ולבטל את כל מהירות היתרונות מגודל הקוד המופחת ולמעשה להוביל לירידה בביצועים הכוללים.

תכנות פונקציונליות פופולריות במיוחד בקרב אקדמאים ומדעני נתונים, מכיוון שהיא יעילה להתמודד עם מניפולציה של מערכי נתונים גדולים.

בהתחשב במיקודו בעיבוד מקביל וחוסר יכולת יכולת, תכנות פונקציונאלית מועילה במיוחד עבור:

• מדעי נתונים
• יישומי גיליון אלקטרוני
• יישומי מימון וסיכון
• עיבוד אצווה

תכנות פונקציונלית: C# לעומת F#

C# ו- F# הם שפות שעולות בפופולריות בשנים האחרונות. למרות ששניהם מרובי פרדיגמות, המוקד העיקרי שלהם שונה, כאשר C# מסתמך על עקרונות חיוניים, חיוניים, וסומכים על עקרונות פונקציונליים. אבל האם האחד מתעלה על השני בכל מה שקשור לתכנות פונקציונלית?

מה זה C#ומי משתמש בזה?

C# היא שפה רב-פרדיגמה, מוכווני אובייקטים, ששוחררה לראשונה על ידי מיקרוסופט לפני כעשרים שנה. כפי שאתה יכול לראות מסטטיסטיקה של השימוש לעיל, זו הייתה השפה השמינית הפופולרית ביותר בקרב מפתחים בשנת 2022, כאשר כמעט שליש מהמפתחים השתמשו בה. יש לו גם ציוני שביעות רצון גבוהים, כאשר שני שלישים ממשתמשי C# אומרים שהם אוהבים להשתמש בו.

C# מוצא שימושים רבים בפיתוח שירותי אינטרנט וענן, כמו גם פיתוח משחקים. חברות ממיקרוסופט ל- TrustPilot ל- StackOverflow יוצרות יישומים ושירותים עם C#.

תכנות פונקציונלית ב- C#

למרות ש- C# הוא בעיקר מכוון לאובייקטים וניתן להשתנות/מצוין, יש לו יכולות פונקציונליות. להלן מספר דרכים ליישום הפרדיגמה הפונקציונלית ב- C#.

ליצור חוסר יכולת

מכיוון שסוגי נתונים ב- C# ניתנים לשינוי מטבעו, כאשר ברצונך להשתמש בעקרונות תכנות פונקציונליים, עליך ליצור חוסר יכולת. וזה מסובך יותר מאשר פשוט להסתמך על סוגי נתונים בלתי ניתנים לשינוי ב- F#. באופן ספציפי, כדי ליצור סוגים בלתי ניתנים לשינוי ב- C#, עליך לבצע את הסוג לקריאה בלבד, להסיר מאפייני סדר, להשתמש בבנאי כדי לספק את הפרמטרים, ואז ליצור מופע חדש בכל פעם שיש צורך בשינוי מצב, במקום להשתלט על מופע קיים.

השתמש בביטוי LINQ ו- Lambda

מיקרוסופט בנתה את המסגרת LINQ (שאילתה משולבת בשפה) במיוחד כדי להכניס תכונות תכנות פונקציונליות ל- C#. LINQ מספק פונקציות להפעלה ברשימות או רצפים, כולל מיפוי (בחר), מיון (סדר) וסינון (היכן). לכל אחד מהביטויים הללו פונקציות לוויכוחים. הביטויים יוצרים מקרים חדשים של הרצף במקום להטיל את הרצף הקיים. LINQ שימושי במיוחד עבור שאילתת מערכי נתונים, בין אם טבלאות SQL, נתוני XML או מקורות אחרים.

LINQ מאפשר גם שימוש בביטויי למבדה, שהם למעשה פונקציות אנונימיות. פונקציות אנונימיות הן היבט מרכזי בתכנות פונקציונלית. ביטויי למבדה יכולים לפעול כטיעונים לפונקציות אחרות בקוד, ליצור פונקציות בסדר גודל גבוה יותר, תכונה נפוצה נוספת של תכנות פונקציונלית.

השתמש בשרשראות שיטה

תכונה נפוצה של F# היא מפעיל הצינור, המעביר את התוצאה של פונקציה אחת לפונקציה אחרת. צנרת אינה מובנית ב- C, אך מפתחים יכולים לחקות צינורות במצבים מסוימים באמצעות שרשראות שיטות, או ממשקים שוטפים. ניתן לבצע זאת באמצעות הפונקציונליות StringBuilder ב- C#.

שרשראות שיטה מאפשרות גם לך לשכפל תכונה נפוצה נוספת של תכנות פונקציונלית, קארי. קארי מאפשר פונקציה עם טיעונים מרובים לקבלת טיעונים אלה בזמנים שונים. בעיקרו של דבר, בתכנות פונקציונלית, אם פונקציה אינה מקבלת את כל הכניסות הדרושות, היא מחזירה פונקציה חדשה עם התשומות החסרות כטיעוניה.

ב- C#, אתה מיישם קאריזציה עם שרשראות שיטה כדי לפרק טיעון רב פונקציונלי לרצף מקונן של מספר פונקציות טיעון יחיד. עם זאת, זה לא מסודר או יעיל כמו ב- f#.

אלה רק חלק מהדרכים שמפתחי C# מיומנים יכולים ליישם עקרונות תכנות פונקציונליים ב- C#. ולמרות שהם עשויים לדרוש מאמץ רב יותר מאשר פשוט להשתמש ב- F#, עבור אותם מפתחים שרוצים את כל שאר התכונות שיש ל- C# להציע, הם אלטרנטיבה ברת קיימא.

מה זה f#ומי משתמש בזה?

F# שוחרר בתחילה על ידי Microsoft עבור פלטפורמת Windows בשנת 2005, F# הוא שפת תכנות פונקציונלית בעיקר. זה התרחב כדי להקיף את פלטפורמות לינוקס ו- MacOS בשנת 2010, ואז JavaScript בשנת 2013. כמו כן, בשנת 2013, קרן התוכנה F# השיקה לתמיכה במיקרוסופט בפיתוח שלה וגם ב- F# וגם בקהילת F#.

מאז הקמתה, קהילת F# צמחה בהתמדה, אם לאט לאט. כעת הוא כולל קבוצת GitHub כמו גם פרויקטים קהילתיים רבים ושונים, החל משדר JavaScript (Fable) ועד מנהלי חבילות (פאקט) ועד ספריות פיתוח אינטרנט (Suave) ועוד.

למרות גילו, ל- F# עדיין יש מקום משמעותי לאימוץ. סטטיסטיקות השימוש הכלליות מעט קשה להגיע אליהן, אך סקר משנת 2021 על ידי Jetbrains של יותר מ -30000 מפתחים ציין שרק 1% השתמשו לאחרונה ב- F# או שתכננו לעשות זאת בעתיד הקרוב. לשם השוואה, 21% השתמשו לאחרונה ב- C#, ו -4% תכננו להשתמש בו בקרוב. ול- F# יש דירוג שביעות רצון מעט נמוך יותר מ- C#, אם כי למעלה מ- 60% מהמפתחים אומרים שהם אוהבים להשתמש בו.

נכון לעכשיו, ישנן פחות ממאה חברות שידועות שמשתמשות ב- F# בייצור, אם כי הן כוללות כמה שמות ידועים כמו וולמארט and HUDDLE.

יש מפתחים המשתמשים ב- F# כהשלמה ל- C#, במקום להסתמך על היכולות הפונקציונליות שקיימות באופן טבעי ב- C#. כי שניהם מתייחסים ל .שפות ביניים נטו (IL), ניתן להשתמש בשניהם באותו פרויקט.

לאיזו שפה יש את הקצה לתכנות פונקציונאלית?

נראה שזו צריכה להיות שאלה מאוד פשוטה לענות עליה: F# הוא תחילה פונקציונלי, בעוד ש- C# הוא תחילה חובה, כך שהקצה עובר ל- f#. וברמה הגבוהה ביותר, הצהרה זו נכונה. אבל פיתוח יישומים, כמו החיים, לעיתים רחוקות די פשוט ליישום הכללי של אמיתות ברמה גבוהה.

השאלה הטובה יותר לשאול היא איזו שפה מתאימה לך, לצוות שלך ולפרויקטים שאתה עובד עליהם כרגע. וזו שאלה הרבה יותר מורכבת לענות.

בחירת השפה הנכונה לתכנות פונקציונלית

בבחירתם בין C# ו- F# לצרכי התכנות הפונקציונליים שלכם, ישנם מספר שיקולים שצריכים להכניס את ההחלטה שלכם:

• מהם צרכי הפרויקט? קבוצות התכונות הספציפיות של היישום שלך עשויות לקחת דרך ארוכה בתהליך ההחלטה. לדוגמה, אם התכונות החשובות ביותר של היישום שלך סובבות סביב אלמנטים של ממשק המשתמש, עם מניפולציה של נתונים קלים בלבד, ייתכן שתרצה להתמקד ב- C#. אבל אם היישום שלך אינטנסיבי של נתונים ורכיבי ממשק המשתמש פחות חשובים, סביר להניח שתשען לעבר f#.
• מהי רמת הנוחות שלך עם כל שפה? אם הבקשה שלך תפיק תועלת מתכנות פונקציונלית, אך אתה לא&rsquo;לא מנוסה מספיק עם C# כדי להתמודד בקלות עם המניפולציות הדרושות כדי ליצור סוגים בלתי ניתנים לשינוי ולתרגם מהצהרות לביטויים, אז כדאי לשקול f#.
• איך הצוות שלך יתמודד עם שפות שונות? כשאתה עובד עם צוות פיתוח, עליך לקחת בחשבון את מערכות המיומנות והניסיון של כל אחד מחברי הצוות. יכול להיות שיש לך מפתח F# מיומן אחד, אבל אחרים עם חשיפה מועטה עד ללא חשיפה ל- f#. זה עלול להוביל לקשיים של חברי הצוות בעבודה עם קוד שנכתב על ידי מפתחים אחרים.
• היא גישה רב-שפתית הטובה ביותר? האם צוות הפיתוח שלך מיומן מספיק כדי לגרום C# וגם F# לעבוד יחד על אותו פרויקט? האם יש סיבות לכך שאחת מהשפות הללו בלבד לא&rsquo;לא מתייחס מספיק לכל צרכי היישום שלך? אבל חשבו היטב לפני שתנקחו גישה זו - עליכם לעשות זאת רק אם היא יעילה ויעילה יותר מאשר להשתמש בשני השפה בנפרד.

סיכום

כאשר פרויקט פיתוח דורש תכנות פונקציונאלית, ישנן אפשרויות רבות העומדות לרשות צוות הפיתוח, החל משפות פונקציונליות גרידא ועד שפות מרובות-פרדיגמה כמו C# ו- F#. ביצוע הבחירה הטובה ביותר בין אפשרויות מתחרות טובות הוא לא תמיד פשוט, אך הזמן שהושקע בקבלת ההחלטה הזו יתוגמל ביעילות פיתוח משופרת ומוצרי סוף טוב יותר.