اف شارپ
اف شارپ (به اختصار: #F) یک نمونهٔ عالی از زبان‌های و چند الگویی می‌باشد که از تکنیک‌های (یا الگوهای) برنامه‌نویسی تابعی، امری و شیءگرایی پشتیبانی می‌کند. از F# اغلب به عنوان یک زبان CLI کراس‌پلتفرم استفاده می‌شود اما از این زبان می‌توان برای تولید کدهای جاوا اسکریپت و کار با GPU استفاده کرد.
F# توسط بنیاد نرم‌افزاری F# توسعه پیدا کرده‌است که شامل: مایکروسافت و بقیه همکاران می‌باشد. متن‌باز بودن و کامپایلر کراس پلتفرم این امکان را به F# می‌دهد تا از آن برای تولید نرم‌افزارهای بنیادی، اصلی و انواع kernelها و … مورد استفاد قرار بگیرد. یکی دیگر از مزیت‌های این زبان پشتیبانی کامل Visual Studio از این زبان می‌باشد به گونه ای که از نسخه ۲۰۰۸ به بعد در تمامی نسخه‌های ویژوال استودیو از این زبان پشتیبانی کامل به عمل آمده که شامل:
و همچنین از دیگر ابزارهای توسعه دهندگان که از زبان F# پشتیبانی می‌کنند، می‌توان به: Mono, MonoDevelop, SharpDevelop and WebSharper اشاره کرد.
F# الهام گرفته شده از زبان برنامه‌نویسی ام‌ال بوده و تحت تأثیر زبان‌های OCaml, C#، پایتون، Haskell, Scala و ارلنگ توسعه پیدا کرده‌است.
F# is a strongly typed functional-first language that uses type inference. Types do not need to be explicitly declared by the programmer; they will be deduced by the compiler during compilation. F# also allows explicit type annotations and requires them in some situations.
F# is an expression-based language using eager evaluation. Every statement in F#, including codice_1 expressions, codice_2 expressions and loops, is a composable expression with a static type. Functions and expressions that do not return any value have a return type of codice_3. F# uses the codice_4 keyword for binding values to a name. For example:
let x = 3 + 4
binds the value codice_5 to the name codice_6.
New types are defined using the codice_7 keyword. For functional programming, F# provides "tuple", "record", "discriminated union", "list" and "option" types. A "tuple" represents a collection of "n" values, where "n" ≥ 0. The value "n" is called the arity of the tuple. A 3-tuple would be represented as codice_8, where A, B and C are values of possibly different types. A tuple can be used to store values only when the number of values is known at design-time and stays constant throughout execution.
A "record" is a type where the data members are named, as in codice_9. Records can be created as codice_10. The codice_11 keyword is used to create a copy of a record, as in codice_12, which creates a new record by copying codice_13 and changing the value of the codice_14 field (assuming the record created in the last example was named codice_13).
A discriminated union type is a type-safe version of C unions. For example,
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 codice_16 notation (codice_17 is the cons operator) or a shorthand as codice_18. An empty list is written codice_19. The "option" type is a discriminated union type with choices codice_20 or codice_21. 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 codice_22 and codice_23 operators.
F# provides "sequence expressions" that define a sequence codice_24, list codice_25 or array codice_26 through code that generates values. For example,
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 generated on-demand (i.e. are lazily evaluated), while lists and arrays are evaluated eagerly.
F# uses تطبیق الگو 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# support for imperative programming includes Values and record fields can also be labelled as codice_32. For example:
// Define 'x' with initial value '1' let mutable x = 1 // Change the value of 'x' to be '3' x CLI languages, can use CLI types and objects through object programming. F# support for object programming in expressions includes:
Support for object programming in patterns includes
F# object type definitions can be class, struct, interface, enum or delegate type definitions, corresponding to the definition forms found in the 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) = F# supports asynchronous programming through "asynchronous workflows". An asynchronous workflow is defined as a sequence of commands inside an codice_43, as in
let asynctask =
The codice_44 allows the rest of the async block to be defined as the delegate and passed as the callback function of an asynchronous operation. This solves the inversion of control problem. The async block is invoked using the codice_45 function. Multiple async blocks are executed in parallel using the codice_46 function that takes a list of codice_47 objects (in the example, codice_48 is an async object) and creates another async object to run the tasks in the lists in parallel. The resultant object is invoked using codice_45.
Parallel programming is supported partly through the codice_46, codice_51 and other operations that run asynchronous blocks in parallel.
Parallel programming is also supported through the codice_52 functional programming operators in the F# standard library, direct use of the codice_53 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.
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.
F# allows some forms of syntax customization to support embedding custom domain-specific languages within the F# language itself, 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 codice_54 attribute can also be accessed in its quotation form. F# quotations are used for various purposes including to compile F# code to جاوااسکریپت and GPU code.
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 فری‌بیس knowledge graph.
In F# 3.0 the F# quotation and computation expression features are combined to implement لینک (زبان برنامه‌نویسی) queries. For example:
// 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 let db = Northwind.GetDataContext()
// A query expression. let query1 = query { for customer in db.Customers do The combination of type providers, queries and strongly typed functional programming is known as "information rich programming".
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 = F# can be developed with any text editor. Specific support exists in editors such as ایمکس.
The Visual F# tools from Microsoft include full IDE integration in Visual Studio. With the language service installed, Visual Studio can be used to create F# projects and the Visual Studio debugger used to debug F# code. In addition, the Visual F# tools comes with a Visual Studio-hosted REPL interactive console that can be used to execute F# code as it is being written.
WebSharper is a framework for cross-tier JavaScript and HTML5 development with F#.
مونودولاپ is an integrated development environment supporting F# programming on Linux, Mac and Windows including support for the interactive console as used by Visual Studio.
SharpDevelop has supported F# since version 3.0.
لینک‌پد has supported F# since version 2.x.
F# is a general purpose programming language.
F# is a central part of the WebSharper framework where F# code is executed as a .NET code on the server and as جاوااسکریپت code on the client-side.
Among others, F# is used for quantitative finance programming, energy trading and portfolio optimization, machine learning, business intelligence and social gaming on Facebook.
In recent years, F# is placed as optimised alternative of C#, F#'s scripting ability and IL compitablility with all Microsoft products have made it popular amongst developers, many developers create solutions based on F# and expose the functionality using C# WCF Services.
F# is often used as a scripting language, mainly for desktop REPL scripting.
The F# open source community includes the F# Software Foundation and the F# Open Source Group at GitHub.
A few small samples follow:
// This is a comment for a sample hello world program. printfn "Hello World!" A Person class with a constructor taking a name and age and two properties.
/// This is a documentation comment for a type definition. type Person(name : string, age : int) = A simple example that is often used to demonstrate the syntax of functional languages is the factorial function for non-negative 32-bit integers, here shown in F#:
/// This is a documentation comment for a function. let rec factorial n = Iteration examples:
/// Iteration using a 'for' loop let printList lst =
/// Iteration using a higher-order function let printList2 lst =
/// Iteration using a recursive function and pattern matching let rec printList3 lst =
Fibonacci examples:
/// Fibonacci Number formula let rec fib n =
/// 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]
// Same thing, using a list expression [ for i in 1..10 do
A sample Windows Forms program:
// 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 =
// Add the label to the form form.Controls.Add(label)
// Finally, run the form [] Application.Run(form)
Asynchronous parallel programming sample (parallel CPU and I/O tasks):
/// A very naive prime number detector let isPrime (n:int) =
// We are using async workflows let primeAsync n =
/// Return primes between m and n using multiple threads let primes m n =
// Run a test primes 1000000 1002000