משתמש:Vexlerr/F Sharp (שפת תכנות)

F#

פרדיגמות	multi-paradigm: פונקציונלית, אימפרטיבית, מונחת-עצמים, metaprogramming, concurrent
תאריך השקה	תבנית:Start date and age, version 1.0
מתכנן	Don Syme, Microsoft Research
מפתח	Microsoft, The F# Software Foundation
טיפוסיות	static, strong, inferred
מימושים	Cross-platform: .NET Framework, Mono, JavaScript
הושפעה על ידי	C#, Erlang, Haskell, ML, OCaml, Python, Scala
השפיעה על	C#, Elm, F*, LiveScript
רישיון	Apache
סיומת	.fs, .fsi, .fsx, .fsscript
fsharp.org

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

F# פותחה על ידי F# Software Foundation, מיקרוסופט ותורמים פתוחים. קומפיילר קוד פתוח זמין באתר הארגון של F# )(F# Software Foundation F# גם נתמך באופן מלא בשפה Visual Studio ו - Xamarin Studio. כלים נוספים התומכים בהתפתחות F# פיתוח הם: Mono, onoDevelop, SharpDevelop, MBrace ו WebSharper. תוספים התומכים ב-F# קיימים בתוכנות עריכה נפוצות רבות, בייחוד התוסף Ionide של Atom ו - Visual Studio Code, ומתכתב עם תוכנות עריכה כגון Vim, Emacs ו Sublime Text.

F# שייכת למשפחת השפות ML ומקורה כיישום דוט נט לשפה OCaml, כמו כן מושפעת מהשפות  C#, פייתון, Haskell, סקאלה, Erlang.

היסטוריה

גרסאות

במהלך הפיתוח שלה, השפה עברה מספר גרסאות:

גרסה	Language specification	תאריך	Platforms	Runtime	Development tools
F# 1.x	May 2005	Windows	.NET 1.0 - 3.5	Visual Studio 2005, Emacs
F# 2.0	August 2010	April 2010	Linux, macOS, Windows	.NET 2.0 - 4.0, Mono	Visual Studio 2010, Emacs
F# 3.0	November 2012	August 2012	Linux, macOS, Windows; JavaScript, GPU	.NET 2.0 - 4.5, Mono	Visual Studio 2012, Emacs WebSharper
F# 3.1	November 2013	October 2013	Linux, macOS, Windows; JavaScript, GPU	.NET 2.0 - 4.5, Mono	Visual Studio 2013, Xamarin Studio Emacs, MonoDevelop SharpDevelop, WebSharper CloudSharper
F# 4.0	January 2016	July 2015	Visual Studio 2015
F# 4.1	March 2017	Linux, macOS, Windows, JavaScript, GPU	.NET 3.5 - 4.6.2, .NET Core, Mono	Visual Studio 2017, Visual Studio for Mac, Ionide, Visual Studio Code, Atom, WebSharper, Rider

Language evolution

F# uses an open development and engineering process. The language evolution process is managed by Don Syme from Microsoft Research as the benevolent dictator for life (BDFL) for the language design, together with the F# Software Foundation. Earlier versions of the F# language were designed by Microsoft and Microsoft Research using a closed development process.

F# originates from Microsoft Research, Cambridge. The language was originally designed and implemented by Don Syme, according to whom the name F# refers to either functional programming or System F. Andrew Kennedy contributed to the design of units of measure. The Visual F# Tools for Visual Studio are developed by Microsoft. The F# Software Foundation developed the F# open-source compiler and

tools, incorporating the open-source compiler implementation provided by the Microsoft Visual F# Tools team.

Summary of versions

F# 1.0	F# 2.0	F# 3.0	F# 3.1	F# 4.0	F# 4.1
Features added	Functional programming Discriminated unions Records Tuples Pattern matching Type abbreviations Object programming Structs Signature files Scripting files Imperative programming Modules (no functors) Nested modules .NET Interoperability	Active patterns Units of measure Sequence expressions Asynchronous programming Agent programming Extension members Named arguments Optional arguments Array slicing Quotations Native interoperability Computation expressions	Type providers LINQ query expressions CLIMutable attribute Triple-quoted strings Auto-properties Provided units-of-measure	Named union type fields Extensions to array slicing Type inference enhancements	Printf on unitized values Extension property initializers Non-null provided types Primary constructors as functions Static parameters for provided methods Printf interpolation Extended #if grammar Support for 'fixed' Tailcall attribute Multiple interface instantiations Optional type args Params dictionaries	Struct tuples which inter-operate with C# tuples Struct annotations for Records Struct annotations for Single-case Discriminated Unions Underscores in numeric literals Caller info argument attributes Result type and some basic Result functions Mutually referential types and modules within the same file Implicit "Module" syntax on modules with shared name as type Byref returns, supporting consuming C# ref-returning methods Error message improvements

סקירת השפה

תכנות פונקציונלי

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

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

טיפוסים חדשים מוגדרים באמצעות type מילת מפתח. עבור תכנות פונקציונלי, F# מספקת את הטיפוסים tuple, record discriminated union, list, option ו result סוגים. . tuple -N-יה סדורה מייצגת קבוצה של n ערכים, כאשר n ≥ 0. הערך n נקרא arity של Nיה סדורה.  3-tuple יהיה מיוצג (A, B, C), כאשר A, B, ו-C הם ערכים של טיפוסים יתכן שונים. Tuple יכול לשמש כדי לאחסן ערכים רק כאשר מספר הערכים בזמן התכנון ונשאר קבוע במהלך הביצוע.

A record is a type where the data members are named, as in [ WRITE THE CODE HERE ]. Records can be created as [ WRITE THE CODE HERE ]. The with keyword is used to create a copy of a record, as in [ WRITE THE CODE HERE ], which creates a new record by copying r and changing the value of the Name field (assuming the record created in the last example was named r).

A discriminated union type is a type-safe version of C unions. For example,

 type A = 
    | UnionCaseX of string
    | UnionCaseY of int

Values of the union type can correspond to either union case. The types of the values carried by each union case is included in the definition of each case.

The list type is an immutable linked list represented either using a [ WRITE THE CODE HERE ] notation (:: is the cons operator) or a shorthand as [ WRITE THE CODE HERE ]. An empty list is written []. The option type is a discriminated union type with choices Some(x) or None. F# types may be generic, implemented as generic .NET types.

F# supports lambda functions and closures. All functions in F# are first class values and are immutable. Functions can be curried. Being first-class values, functions can be passed as arguments to other functions. Like other functional programming languages, F# allows function composition using the >> and << operators.

F# provides sequence expressions that define a sequence seq { ... }, list [ ... ] or array [| ... |] through code that generates values. For example,

 seq { for b in 0 .. 25 do
           if b < 15 then
               yield b*b }

forms a sequence of squares of numbers from 0 to 14 by filtering out numbers from the range of numbers from 0 to 25. Sequences are generators – values are generated on-demand (i.e., are lazily evaluated) – while lists and arrays are evaluated eagerly.

F# uses pattern matching to bind values to names. Pattern matching is also used when accessing discriminated unions – the union is value matched against pattern rules and a rule is selected when a match succeeds. F# also supports Active Patterns as a form of extensible pattern matching. It is used, for example, when multiple ways of matching on a type exist.

F# supports a general syntax for defining compositional computations called computation expressions. Sequence expressions, asynchronous computations and queries are particular kinds of computation expressions. Computation expressions are an implementation of the monad pattern.

חובה תכנות

F# תומכת בתכנות אימפרטיבי כולל

• לולאות for
• לולאות while
• מערכים, יצירה על ידי תחביר כזה: [| ... |] 
• טבלת גיבוב, יצירה על ידי תחביר dict [ ... ] תחביר או טיפוסי <_,_>System.Collections.Generic.Dictionary

ערכים ושדות ניתן גם להגדיר בתור mutable. לדוגמה: כמו כן, F# תומך בגישה לכל טיפוסי CLI ואובייקטים כגון אלה שהוגדרו במרחב השמות System.Collection.Generic של מבני נתונים אימ.

Object programming

Like other Common Language Infrastructure (CLI) languages, F# can use CLI types and objects through object programming. F# support for object programming in expressions includes:

• סימון-נקודה, למשל, x.Name 
• ביטויי אובייקט   new obj() with member x.ToString() = "hello" }
• אובייקט בנייה, למשל, new Form()
• טיפוסי בדיקות, למשל, x :? string
• ype coercions, e.g., x :?> string 
• פרמטרים עם שם, למשל,.Method(someArgument=1)
• בשם דפוס, למשל,new Form(Text="Hello")
  
• ארגומנטים אופציונליים, למשל x.Method(OptionalArgument=1)

• Type tests, e.g., [ WRITE THE CODE HERE ]
• Active patterns, which can be defined over object types

F# object type definitions can be class, struct, interface, enum, or delegate type definitions, corresponding to the definition forms found in C#. For example, here is a class with a constructor taking a name and age, and declaring two properties.

/// A simple object type definition
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age

תכנות אסינכרוני

F# supports asynchronous programming through asynchronous workflows. An asynchronous workflow is defined as a sequence of commands inside an async{ ... }, as in

let asynctask = 
    async { let req = WebRequest.Create(url)
            let! response = req.GetResponseAsync()
            use stream = response.GetResponseStream()
            use streamreader = new System.IO.StreamReader(stream)
            return streamreader.ReadToEnd() }

The let! indicates that the expression on the right (getting the response) should be done asynchronously but the flow should only continue when the result is available. In other words, from the point of view of the code block, it's as if getting the response is a blocking call, whereas from the point of view of the system, the thread won't be blocked and may be used to process other flows while the result needed for this one doesn't become available.

The async block may be invoked using the Async.RunSynchronously function. Multiple async blocks can be executed in parallel using the Async.Parallel function that takes a list of async objects (in the example, asynctask is an async object) and creates another async object to run the tasks in the lists in parallel. The resultant object is invoked using Async.RunSynchronously. Inversion of control in F# follows this pattern.

תכנות מקביל

Parallel programming is supported partly through the Async.Parallel, Async.Start and other operations that run asynchronous blocks in parallel.

Parallel programming is also supported through the Array.Parallel functional programming operators in the F# standard library, direct use of the System.Threading.Tasks task programming model, the direct use of .NET thread pool and .NET threads and through dynamic translation of F# code to alternative parallel execution engines such as GPU code.

Units of measure

The F# type system supports units of measure checking for numbers. The units of measure feature integrates with F# type inference to require minimal type annotations in user code.

Metaprogramming

F# allows some forms of syntax customizing via metaprogramming to support embedding custom domain-specific languages within the F# language, particularly through computation expressions.

F# includes a feature for run-time meta-programming called quotations. A quotation expression evaluates to an abstract syntax representation of F# expressions. A definition labelled with the [<ReflectedDefinition>] attribute can also be accessed in its quotation form. F# quotations are used for various purposes including to compile F# code to JavaScript and GPU code.

Information-rich programming

F# 3.0 introduced a form of compile-time meta-programming through statically extensible type generation called F# type providers. F# type providers allow the F# compiler and tools to be extended with components that provide type information to the compiler on-demand at compile time. F# type providers have been used to give strongly typed access to connected information sources in a scalable way, including to the Freebase knowledge graph.

// Use the OData type provider to create types that can be used to access the Northwind database.
open Microsoft.FSharp.Data.TypeProviders

type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc">
let db = Northwind.GetDataContext()

// A query expression.
let query1 = query { for customer in db.Customers do
                     select customer }

סוכנות תכנות

F# supports a variation of the Actor programming model through the in-memory implementation of lightweight asynchronous agents. For example, the following code defines an agent and posts 2 messages:

let counter =
    MailboxProcessor.Start(fun inbox ->
        let rec loop n =
            async { do printfn "n = %d, waiting..." n
                    let! msg = inbox.Receive()
                    return! loop(n+msg) }
        loop 0)

כלי פיתוח

• The Visual F# tools from Microsoft include full integrated development environment (IDE) integration in Visual Studio. With the language service installed, Visual Studio can be used to create F# projects and its debugger used on F# code. The Visual F# tools include a Visual Studio-hosted read–eval–print loop (REPL) interactive console that can execute F# code as it is written. Visual Studio for Mac also fully supports F# projects.
• Visual Studio Code contains full support for F# via the Ionide extension.
• F# can be developed with any text editor. Specific support exists in editors such as Emacs.
• Fable, the F# |> Babel project, provides support for targeting JavaScript as a compilation backend for F# code.
• WebSharper is a framework for cross-tier JavaScript and HTML5 development with F#.
• MonoDevelop is an integrated development environment supporting F# programming on Linux, macOS, and Windows including support for the interactive console as used by Visual Studio.
• SharpDevelop has supported F# since version 3.0.
• MBrace is a framework and runtime for the development of applications with F# for the cloud.
• LINQPad has supported F# since version 2.x.
• Xamarin Studio supports F# since version 3.0.

Web programming

F# is a central part of the WebSharper framework where F# code is executed as .NET code on a server and as JavaScript code on a client.

Analytical programming

Among others, F# is used for quantitative finance programming, energy trading and portfolio optimization, machine learning, business intelligence and social gaming on Facebook.

In the 2010s, F# has been positioned as an optimized alternative to C#. F#'s scripting ability and IL compatibility with all Microsoft products have made it popular among developers. Many developers are creating systems based on F# and use C# WCF Services.^{[דרושה הבהרה][דרוש מקור]}תבנית:Who

Scripting

F# can be used as a scripting language, mainly for desktop read–eval–print loop (REPL) scripting.

קהילת קוד פתוח

The F# open-source community includes the F# Software Foundation and the F# Open Source Group at GitHub.

תאימות

F# features a legacy "ML compatibility mode" that can directly compile programs written in a large subset of OCaml roughly, with no functors, objects, polymorphic variants, or other additions.

דוגמאות

// This is a comment for a sample hello world program.
open System
Console.WriteLine("Hello World!")

/// This is a documentation comment for a type definition.
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age

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

/// This is a documentation comment for a function.
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)

/// Iteration using a 'for' loop
let printList lst = 
    for x in lst do
        printfn "%d" x

/// Iteration using a higher-order function
let printList2 lst = 
    List.iter (printfn "%d") lst

/// Iteration using a recursive function and pattern matching
let rec printList3 lst =
    match lst with
    | [] -> ()
    | h :: t ->
        printfn "%d" h
        printList3 t

/// Fibonacci Number formula
let rec fib n =
    match n with
    | 0 | 1 -> n
    | _ -> fib (n - 2) + fib (n - 1)

/// Another approach - a lazy infinite sequence of Fibonacci numbers
let fibSeq = Seq.unfold (fun (a,b) -> Some(a+b, (b, a+b))) (0,1)

// Print even fibs
[1 .. 10]
|> List.map     fib
|> List.filter  (fun n -> (n % 2) = 0)
|> printList

// Same thing, using a list expression
[ for i in 1..10 do
    let r = fib i
    if r % 2 = 0 then yield r ]
|> printList

// Open the Windows Forms library
open System.Windows.Forms

// Create a window and set a few properties
let form = new Form(Visible=true, TopMost=true, Text="Welcome to F#")

// Create a label to show some text in the form
let label =
    let x = 3 + (4 * 5)
    new Label(Text = sprintf "x = %d" x)

// Add the label to the form
form.Controls.Add(label)

// Finally, run the form
[<System.STAThread>]
Application.Run(form)

דוגמה לתכנות אסינכרוני מקביל (parallel CPU and I/O):

/// A simple prime number detector
let isPrime (n:int) =
   let bound = int (sqrt (float n))
   seq {2 .. bound} |> Seq.forall (fun x -> n % x <> 0)

// We are using async workflows
let primeAsync n =
    async { return (n, isPrime n) }

/// Return primes between m and n using multiple threads
let primes m n =
    seq {m .. n}
        |> Seq.map primeAsync
        |> Async.Parallel
        |> Async.RunSynchronously
        |> Array.filter snd
        |> Array.map fst

// Run a test
primes 1000000 1002000
    |> Array.iter (printfn "%d")

ראו גם

• OCaml
• C שארפ (שפת תכנות) (C#)
• .NET Framework
• סקאלה (שפת תכנות)
• Clojure
• הסקל (שפת תכנות)
• Nemerle

המלצות

• Syme, Don; Granicz, Adam; Cisternino, Antonio (2007). "Expert F#". Apress. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Harrop, Jon (2010). "Visual F# 2010 for Technical Computing". Flying Frog Consultancy. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Pickering, Robert (2007). "Foundations of F#". Apress. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Smith, Chris (2009). "Programming F#". O'Reilly. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Petricek, Tomas (2009). "Real World Functional Programming With Examples in F# and C#". Manning Publications. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Hansen, Michael; Rischel, Hans (2013). "Functional Programming Using F#". Cambridge University Press. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Astborg, Johan (2013). "F# for Quantitative Finance". Packt Publishing. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)
• Lundin, Mikael (2015). "Testing with F#". Packt Publishing. {{cite journal}}: Cite journal requires |journal= (עזרה); לא תקין |ref=harv (עזרה)

קישורים חיצוניים

• אתר האינטרנט הרשמי של Vexlerr/F Sharp The F# Software Foundation
• The F# Open Source Group at GitHub
• The Visual F# Developer Center
• Tsunami, an embeddable desktop F# IDE
• Cloud Tsunami, an embeddable Silverlight F# IDE
• Try F#, for learning F# in a web browser
• F# Snippets Site
• The Visual F# team blog
• The original Microsoft Research website for F#
• Planet F#
• The F# Survival Guide, Dec 2009 (Web-based book)
• The F# Language Specification
• An introduction to F# programming
• A tutorial showing the process of reaching a functional design; includes test and parallel coding

הערות שוליים

קטגוריה:שפות תכנות