എഫ് ഷാർപ്പ് (പ്രോഗ്രാമിങ് ഭാഷ)

എഫ്#(F#) (ഉച്ചരിക്കുന്നത് എഫ് ഷാർപ്പ്) ഫംഗ്ഷണൽ, ഇംപെറേറ്റീവ്, ഒബ്ജക്റ്റ് ഓറിയെന്റഡ് പ്രോഗ്രാമിങ് രീതികൾ ഉൾക്കൊള്ളുന്ന ശക്തമായ ടൈപ്പ്, ഒന്നിലധികം മാത‌ൃകൾ ഉള്ള പ്രോഗ്രാമിങ് ഭാഷയാണ്. ക്രോസ് പ്ലാറ്റ്ഫോമായ കോമൺ ലാംഗ്വേജ് ഇൻഫ്രാസ്ട്രക്ചർ (CLI) ഭാഷയായി എഫ് # ഉപയോഗിക്കാറുണ്ടെങ്കിലും പക്ഷെ അത് ജാവാസ്ക്രിപ്റ്റും ഗ്രാഫിക്സ് പ്രോസസ്സിംഗ് യൂണിറ്റും (ജിപിയു) കോഡ് ജനറേറ്റ് ചെയ്യുന്നതിനും കഴിയും. എഫ്# സോഫ്റ്റ്‌വേർ ഫൗണ്ടേഷൻ, മൈക്രോസോഫ്റ്റ്, തുറന്ന സംഭാവനക്കാർ എന്നിവർ ചേർന്ന് വികസിപ്പിച്ചെടുത്തു. എഫ് # സോഫ്റ്റുവെയർ ഫൌണ്ടേഷനിൽ നിന്നും ഓപ്പൺ സോഴ്സ്, ക്രോസ് പ്ലാറ്റ്ഫോം കമ്പൈലർ ലഭ്യമാണ്.എഫ്#  വിഷ്വൽ സ്റ്റുഡിയോ ,സമറിൻ സ്റ്റുഡിയോ(Xamarin studio) എന്നിവയിൽ പൂർണ്ണ പിന്തുണയുള്ള ഭാഷയാണ്.മോണോ, മോണോഡെവലപ്പ്, ഷാർപ്ഡെവലപ്പ്, എംബിറേസ്, വെബ് ഷാർപർ എന്നിവയാണ് എഫ് ഡെവലപ്മെന്റ് മറ്റ് ഉപകരണങ്ങളെ പിന്തുണയ്ക്കുന്നത്. Pickering, Robert (2009). Beginning F#, Apress. p. 11. പ്ലഗ് ഇൻസ് പിന്തുണയ്ക്കുന്ന എഫ്# വ്യാപകമായി ഉപയോഗിക്കുന്ന എഡിറ്റർമാർക്ക്, പ്രത്യേകിച്ച് ആറ്റത്തിനും വിഷ്വൽ സ്റ്റുഡിയോ കോഡിനായുള്ള ഇയോണൈഡ് എക്സ്റ്റൻഷൻ, വിം, എമാക്സ്, ആൻഡ് സബ്ബ് ലൈം ടെക്സ്റ്റ് തുടങ്ങിയ മറ്റ് എഡിറ്ററുകൾക്കുള്ള സംയോജനമാണ്.

എഫ്# എം.എൽ. ഭാഷാ കുടുംബത്തിലെ അംഗം ആണ്. പ്രോഗ്രാമിങ് ഭാഷ ഓക്കമിലെ ഒരു കോറിന്റെ ഒരു .നെറ്റ് ഫ്രെയിംവർക്ക്‌  ഇംപ്ലിമെന്റേഷൻ ആയിത്തീർന്നു. സി#, പൈത്തൺ, ഹാസ്കൽ, സ്കാല, എർലാങ്.
ചരിത്രം
പതിപ്പുകൾ
എഫ് ഷാർപ്പിന്റെ വികസനത്തിൽ, ഭാഷ പല പതിപ്പുകളിലൂടെ കടന്നുപോയിട്ടുണ്ട്:
 പതിപ്പ് ഭാഷാ സവിശേഷത തീയതി പ്ലാറ്റ്ഫോമുകൾ	 റൺടൈം വികസന ഉപകരണങ്ങൾ എഫ്# 1.x  മെയ് 2005വിൻഡോസ്.നെറ്റ് 1.0 - 3.5വിഷ്വൽ സ്റ്റുഡിയോ 2005, ഇമാക്സ് എഫ്# 2.0 August 2010 April 2010ലിനക്സ്, മാക്ഒഎസ്, വിൻഡോസ് .നെറ്റ് 2.0 - 4.0, മോണോവിഷ്വൽ സ്റ്റുഡിയോ 2010, ഇമാക്സ്‌ എഫ്# 3.0 November 2012 August 2012Linux, macOS, Windows;JavaScript, GPU.NET 2.0 - 4.5, MonoVisual Studio 2012, EmacsWebSharper എഫ്# 3.1 November 2013 October 2013Linux, macOS, Windows;JavaScript, GPU.NET 2.0 - 4.5, MonoVisual Studio 2013, Xamarin StudioEmacs, MonoDevelopSharpDevelop, WebSharperCloudSharper എഫ്# 4.0 January 2016 July 2015Visual Studio 2015എഫ്# 4.1മാർച്ച് 2017ലിനക്സ്, മാക്ഒഎസ്, വിൻഡോസ്,
ജാവാസ്ക്രിപ്റ്റ്, ജിപിയു.NET 3.5 - 4.6.2, .NET Core, MonoVisual Studio 2017, Visual Studio for Mac, 
Ionide, വിഷ്വൽ സ്റ്റുഡിയോ കോഡ്, ആറ്റം, WebSharper, 
Riderഎഫ്# 4.5August 2018https://blogs.msdn.microsoft.com/dotnet/2018/08/14/announcing-f-4-5/Linux, macOS, Windows,
JavaScript, GPU .NET 4.5 - 4.7.2,https://www.nuget.org/packages/FSharp.Core# .NET Core SDK 2.1.400Visual Studio 2017 15.8, Visual Studio for Mac, 
Ionide, Visual Studio Code, Atom, WebSharper, 
Rider
എഫ്# ഇൻട്രാറ്റീവ്(REPL(റീഡ്-ഇവാലുവേറ്റ്-പ്രിന്റ് ലൂപ്പ്) റഫർ ചെയ്യുന്നതിനായി എഫ് # ഉപയോഗിക്കുന്നു) .നെറ്റ് ഫ്രെയിംവർക്കിൽ മാത്രമേ പ്രവർത്തിക്കുകയുള്ളു എന്നത് ശ്രദ്ധിക്കുക. അതുകൊണ്ടാണ് വിൻഡോസിൽ മാത്രം പ്രവർത്തിക്കുന്നത്.https://www.reddit.com/r/programming/comments/97cnsp/announcing_f_45/

ഭാഷ പരിണാമം
എഫ്# തുറന്ന വികസനവും സാങ്കേതികവിദ്യയും ഉപയോഗിക്കുന്നു. മൈക്രോസോഫ്റ്റിന്റെ റിസർച്ചിൽ നിന്നുള്ള ഡോൺ സൈമെ ഭാഷാ പരിണാമ പ്രക്രിയയെ കൈകാര്യം ചെയ്യുന്നു,  ഭാഷ, ഡിസൈൻ എന്നിവയക്കുവേണ്ടി ബെനവലൻറ് ഡിക്റ്റേറ്റർ ഫോർ ലൈഫ് (ബി.ഡി.എഫ്.എൽ) ആകുകയും, കൂടാതെ എഫ് # സോഫ്റ്റ് വെയർ ഫൗണ്ടേഷനോടൊപ്പം പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. എഫ്# ഭാഷയുടെ മുൻപതിപ്പുകൾ രൂപകൽപ്പന ചെയ്തത് മൈക്രോസോഫ്റ്റ്, മൈക്രോസോഫ്റ്റ് റിസർച്ച് തുടങ്ങിയവയാണ്.

എഫ്# കേംബ്രിഡ്ജ്, മൈക്രോസോഫ്റ്റ് റിസേർച്ച്  മുതലായവയിൽ നിന്നാണ് പരിണമിച്ചത്. ഭാഷ ആദ്യം രൂപകൽപ്പന ചെയ്ത് നടപ്പിലാക്കിയത് ഡോൺ സൈമെ ആണ്, എഫ് ഷാർപ്പ് ടീമിലെ ആരോ പറഞ്ഞതനുസരിച്ച്  അവർ പറയുന്നു എഫ് "തമാശ"ക്ക് വേണ്ടിയാണ്.യൂണിറ്റുകളുടെ രൂപകൽപ്പനയ്ക്ക് ആൻഡ്രൂ കെന്നഡി സംഭാവന നൽകി. വിഷ്വൽ സ്റ്റുഡിയോയ്ക്കുള്ള വിഷ്വൽ എഫ് # ടൂളുകൾ മൈക്രോസോഫ്റ്റ് വികസിപ്പിച്ചതാണ്. എഫ്# സോഫ്റ്റ്‌വേർ ഫൗണ്ടേഷൻ എഫ് # ഓപ്പൺ സോഴ്സ് കമ്പൈലർ, ടൂളുകൾ എന്നിവ വികസിപ്പിച്ചെടുത്തു, ലഭ്യമാക്കിയ ഓപ്പൺ സോഴ്സ് കമ്പൈലർ സംയോജിപ്പിക്കുന്നു, ഇത് മൈക്രോസോഫ്റ്റ് വിഷ്വൽ എഫ് # ടൂൾസ് ടീം നൽകുന്നതാണ്.
+ Summary of versions  F# 1.0  F# 2.0  F# 3.0  F# 3.1  F# 4.0  F# 4.1F# 4.5Featuresadded 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
 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
 Support for 'fixed' Versioning alignment of binary, package, and language
 Support for 'Span<T>' and related types
 Ability to produce 'byref' returns
 The 'voidptr' type
 The 'inref<'T>' and 'outref<'T>' types to represent readonly and write-only 'byref's
 'IsByRefLike' structs
 'IsReadOnly' structs
 Extension method support for 'byref<'T>'/'inref<'T>'/'outref<'T>'
 'match!' keyword in computation expressions
 Relaxed upcast with 'yield' in F# seq/list/array expressions
 Relaxed indentation with list and array expressions
 Enumeration cases emitted as public
ഭാഷാ വിഹഗവീക്ഷണം
പ്രവർത്തന പ്രോഗ്രാമിംഗ്
എഫ് # എന്നത് ശക്തമായി ടൈപ്പ് (strongly typed)ചെയ്ത ഫംഗ്ഷൻ-ടൈപ്പ് അനുമാനം ഉപയോഗിക്കുന്ന ഭാഷയാണ്. പ്രോഗ്രാമർ തരങ്ങൾ പ്രഖ്യാപിക്കേണ്ട ആവശ്യമില്ല—കമ്പൈലർ സമയത്ത് തരം തിരിച്ചെടുക്കുന്നു (തരം അനുമാനം). എഫ്# സ്പഷ്ടമായ തരത്തിലുള്ള വ്യാഖ്യാനങ്ങളെ അനുവദിക്കുന്നു, അവ ചില സാഹചര്യങ്ങളിൽ ആവശ്യമാണ്.

എഫ്# ആഴത്തിലുള്ള മൂല്യനിർണ്ണയം ഉപയോഗിക്കുന്ന ഒരു എക്സ്പ്രഷൻ അടിസ്ഥാനമാക്കിയുള്ള ഭാഷയാണ്. if എക്സ്പ്രഷനുകൾ ഉൾപ്പെടെ, tryഎക്സ്പ്രഷനുകളും ലൂപുകളും, ഒരു സ്റ്റാറ്റിക് തരത്തിലുള്ള ഒരു സങ്കലന എക്സ്പ്രഷനാണ്.  ഫങ്ഷനുകളും എക്സ്പ്രഷനുകളും മടക്കിനൽകാത്ത മൂല്ല്യം unitതരത്തിലൂടെ മടക്കിനൽകുന്നു. എഫ് # നാമത്തിലേക്ക് ബൈൻഡ് മൂല്ല്യങ്ങൾക്ക് let കീവേർഡ് ഉപയോഗിയ്ക്കുന്നു. ഉദാഹരണത്തിന്:
let x = 3 + 4
x എന്ന പേരിലേക്കു് 7 എന്ന മൂല്യം ബന്ധിപ്പിക്കുന്നു.

typeകീവേഡ് ഉപയോഗിച്ച് ആണ് പുതിയ തരം നിർവചിച്ചിരിക്കുന്നത്. ഫങ്ഷണൽ പ്രോഗ്രാമിങ്ങിനായി, എഫ്# ടപ്പിൾ, റെക്കോർഡ്, വിവേചനമുള്ള യൂണിയൻ, ലിസ്റ്റ്, ഓപ്ഷൻ, ഫലങ്ങളുടെ തരം എന്നിവ ലഭ്യമാക്കുന്നു. ഒരു ടപ്പിൾ ഒരു n ന്റെ മൂല്യങ്ങളെ പ്രതിനിധീകരിക്കുന്നു, ഇവിടെ n ≥ 0. മൂല്യം n എന്നത് ടപ്പിളിന്റെ അരിറ്റി എന്ന് വിളിക്കുന്നു. A, B, C എന്നിവ വ്യത്യസ്ത തരങ്ങളുടെ മൂല്യങ്ങളാണെങ്കിൽ 3-ടപ്പിൾ പ്രതിനിധാനം ചെയ്യപ്പെടും (A, B, C).മൂല്യങ്ങളുടെ എണ്ണം ഡിസൈൻ സമയത്തെ അറിയുമ്പോഴും എക്സിക്യൂഷൻ സമയത്ത് സ്ഥിരമായി നിൽക്കുമ്പോഴും മാത്രം മൂല്യങ്ങൾ സൂക്ഷിക്കാൻ ഒരു ടപ്പിൾ ഉപയോഗപ്പെടുത്താം.

ഡേറ്റാ അംഗങ്ങളെ പേരുനൽകുന്ന ഒരു റെക്കോർഡാണ് റെക്കോർഡ്. റെക്കോർഡ് നിർവചനത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ:
 type R = 
        { Name : string 
         Age : int }
നമുക്ക്  എന്ന് രേഖപ്പെടുത്താം, withകീവേഡ് റെക്കോഡിന്റെ പകർപ്പാണു് ഉപയോഗിയ്ക്കുന്നതു്, ഉദാഹരണമായി {r = name = "CD"} ൽ, ഇതു് ഒരു പുതിയ റിക്കോർഡ് ഉണ്ടാക്കുക വഴി, r ന്റെ പകർപ്പെടുത്തു് മാറ്റുക, നെയിം ഫീൽഡിന്റെ മൂല്യം മാറ്റുക (അവസാനത്തെ ഉദാഹരണത്തിൽ ഉണ്ടാക്കിയ റെക്കോർഡ് r പേരാണ് നൽകിയിരുന്നത്).

വ്യത്യസ്ത യൂണിയൻ തരം എന്നത് സി യൂണിയനുകളുടെ തരം സുരക്ഷയുള്ള പതിപ്പാണ്. ഉദാഹരണത്തിന്,
 type R = 
        { Name : string 
         Age : int }
യൂണിയൻ രീതിയുടെ മൂല്യങ്ങൾ ഒന്നുകിൽ യൂണിയൻ കേസായിരിക്കും. ഓരോ കേസിന്റെയും നിർവ്വചനത്തിൽ ഓരോ യൂണിയൻ കേസുകളും വഹിക്കുന്ന മൂല്യങ്ങളുടെ രീതി ഉൾപ്പെടുത്തിയിരിക്കുന്നു.

ലിസ്റ്റ് തരം മാറ്റാൻപറ്റാത്തതാണ്, ലിങ്ക്ഡ് ലിസ്റ്റ് head::tailനൊട്ടെഷനെ പ്രതിനിധീകരിക്കുന്നു(:: എന്നത് കോൺസ് ഓപ്പറേറ്ററാണ്) അല്ലെങ്കിൽ [item1; item2; item3]എന്നിങ്ങനെ ചുരുക്കിയെഴുതുവാൻ സാധിക്കും. ഒരു ശൂന്യമായ പട്ടിക എഴുതിയിട്ടുണ്ട്[ ]. ഓപ്ഷൻ തരം വേർതിരിച്ച് അറിയാൻ കഴിയുന്ന യൂണിയൻ ടൈപ്പാണ്. ഓപ്ഷനുകൾ Some(x) or None ചോയ്സുകൾ ഉള്ള ഒരു വിവേചന യൂണിയൻ തരമാണ്. എഫ് # തരം സാധാരണയായിരിക്കാം, അത് സാധാരണ .നെറ്റ് തരങ്ങളായി നടപ്പിലാക്കാം. 

എഫ്# ലാംഡ ഫംഗ്ഷനുകളും ക്ലോസ്സേഴ്സും പിന്തുണയ്ക്കുന്നു. എഫ്# ലെ എല്ലാ ഫംഗ്ഷനുകളും ഫസ്റ്റ് ക്ലാസ് മൂല്യങ്ങളും മാറ്റമില്ലാത്തവയുമാണ്.
ഫങ്ഷനുകൾ കറീഡാകാൻ(curried) കഴിയും. ഫസ്റ്റ് ക്ലാസ് മൂല്യങ്ങളാണെങ്കിൽ, മറ്റ് പ്രവർത്തനങ്ങൾക്ക് ആർഗ്യുമെന്റായി നൽകാം. മറ്റ് പ്രവർത്തന പ്രോഗ്രാമിംഗ് ഭാഷകളെ പോലെ,>>, << ഓപ്പറേറ്റഴ്സ് മുഖേന ഫങ്ഷൻ ഘടനയെ എഫ് ഷാർപ്പിൽ ഉപയോഗിക്കുന്നതിന് സഹായിക്കുന്നു.എഫ് # സീക്വൻസ് എക്സ്പ്രഷനുകൾ നൽകുന്നു, ഒരു സീക്വൻസ്  seq {...} നിർവചിക്കുക, list [...]  അല്ലെങ്കിൽ അറേ[| ... |] എന്നീ കോഡുകൾ വഴി മൂല്യങ്ങൾ സൃഷ്ടിക്കുന്ന‌ു. ഉദാഹരണത്തിന്,
 seq { for b in 0 .. 25 do
           if b < 15 then
               yield b*b }
0 മുതൽ 25 വരെയുള്ള സംഖ്യകളുടെ ശ്രേണിയിൽ നിന്ന് സംഖ്യകൾ 0 ഫിൽറ്റർ ചെയ്തുകൊണ്ട് സംഖ്യകളുടെ സ്ക്വയറുകളുടെ ഒരു ശ്രേണീ ആരംഭിക്കുന്നു. സീക്വൻസ് എന്നത് ജനറേറ്ററാണ് - മൂല്യങ്ങൾ ഡിമാന്റിൽ ജനറേറ്റുചെയ്യപ്പെടുന്നു (അതായത്, ലാളിത്യമായി വിലയിരുത്തുകയാണ്) - ലിസ്റ്റുകളും അറേകളും ഔത്സുക്യത്തോടെ വിലയിരുത്തുന്നു. പേരുകളിലേക്ക് മൂല്യങ്ങൾ ബന്ധിപ്പിക്കുന്നതിന് പാറ്റേൺ പൊരുത്തപ്പെടുന്ന രീതി എഫ് ഷാർപ്പ് ഉപയോഗിക്കുന്നു. മാത്രമല്ല വിവേചനപൂർണ്ണമായ യൂണിയനുകൾ ഉപയോഗിക്കുമ്പോഴും പാറ്റേൺ പൊരുത്തപ്പെടൽ ഉപയോഗിക്കപ്പെടുന്നു, യൂണിയൻ എന്നത് പാറ്റേൺ നിയമങ്ങൾക്കെതിരായി പൊരുത്തപ്പെടുന്നു, അവ തമ്മിലുള്ള ചേർച്ച വിജയിക്കുമ്പോൾ ഒരു റൂൾ തിരഞ്ഞെടുക്കുന്നു. എക്സ്റ്റൻസിബിൾ പാറ്റേൺ പൊരുത്തപ്പെടുന്ന രൂപത്തിൽ എഫ്# സജീവ ഇനങ്ങളെ പിന്തുണയ്ക്കുന്നു. ഉദാഹരണത്തിന്, നിലവിലുള്ള തരത്തിൽ പൊരുത്തപ്പെടുത്തലുകൾ ഒന്നിലധികം ഉണ്ടാകുമ്പോൾ ആണ് ഇത് ഉപയോഗിക്കുന്നത്.

കമ്പ്യൂട്ടേഷൻ എക്സ്പ്രഷനുകൾ എന്ന് വിളിക്കുന്ന രചനാപരമായ കണക്കുകൂട്ടലുകൾ നിർവ്വചിക്കുന്നതിനുള്ള ഒരു സാധാരണ വാക്യഘടന എഫ്# പിന്തുണയ്ക്കുന്നു. സീക്വൻസ് എക്സ്പ്രഷനുകൾ, എസിങ്ക്രണസ് കണക്കുകൂട്ടൽ, ക്വറികൾ എന്നിവയാണ് കംപ്യൂട്ടിംഗ് എക്സ്പ്രഷനുകളുടെ പ്രത്യേകതകൾ. കണക്കുകൂട്ടൽ സമ്പ്രദായങ്ങൾ മൊനാഡ് മാതൃകയുടെ ഒരു നിർവ്വഹണമാണ്.
ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗ്
ഇംപെറേറ്റീവ് പ്രോഗ്രാമിംഗിനുള്ള എഫ്# പിന്തുണ ഉൾപ്പെടുന്നവ താഴെ കൊടുത്തിരിക്കുന്നതു പ്രകാരമാണ്
 forലൂപ്പുകൾ
whileലൂപ്പുകൾ
whileലൂപ്പുകൾ
 അറേകൾ [| ... |]സ‌ൃഷ്ടിച്ച വാക്യഘടന
 ഹാഷ് ടേബിൾ, dict[...] സിന്റാക്സ് ഉപയോഗിച്ച് സൃഷ്ടിച്ചു അല്ലെങ്കിൽ System.Collections.Generic.Dictionary <_, _>തരം ഉപയോഗപ്പെടുത്തുന്നു.

മൂല്യങ്ങളും റെക്കോർഡ് ഫീൽഡുകളും mutable നെ ലേബൽ ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്:
// Define 'x' with initial value '1'
let mutable x = 1
// Change the value of 'x' to '3'
x <- 3
നെയിംസ്പേസ് അനിവാര്യ ഡാറ്റ ഘടനകളെ നിർവചിക്കുന്നു. കൂടാതെ, എല്ലാ സിഎൽഐ(CLI) ടൈപ്പുകൾക്കും System.Collections.Generic namespace എന്നിവയിൽ നിർവചിക്കപ്പെട്ടിട്ടുള്ളവയിലേക്കും പ്രവേശനത്തിന് എഫ്# പിന്തുണ നൽകുന്നു.
ഒബ്ജക്റ്റ് പ്രോഗ്രാമിംഗ്
മറ്റ് പൊതു ഭാഷാ ഇൻഫ്രാസ്ട്രക്ചർ (CLI) ഭാഷകൾ പോലെ, എഫ്# ഓബ്ജക്റ്റ് പ്രോഗ്രാമിങ്ങിലൂടെ സിഎൽഐ(CLI) തരങ്ങളും വസ്തുക്കളും ഉപയോഗിക്കാൻ കഴിയും. ഒബ്ജക്റ്റ് പ്രോഗ്രാമിങ്ങിനായുള്ള എഫ്# പിന്തുണയിൽ ഉൾപ്പെടുന്നവ:
 ഡോട്ട് നൊട്ടേഷൻ, ഉദാ., X.Name
 ഒബ്ജക്റ്റ് എക്സ്പ്രഷനുകൾ, ഉദാ., }
 ഒബ്ജക്റ്റ് നിർമ്മാണം, ഉദാ.,
 ടൈപ്പുചെയ്യൽ സമ്മർദ്ദങ്ങൾ(type coercions), ഉദാ 
 പേരുള്ള ആർഗ്യുമെന്റുകൾ, ഉദാ. 
 പേരുനൽകിയ സെറ്ററുകൾ, ഉദാ. 
 ഓപ്ഷണൽ ആർഗ്യുമെന്റുകൾ, ഉദാ. 

പാറ്റേണുകളിൽ ഒബ്ജക്റ്റ് പ്രോഗ്രാമിനുള്ള പിന്തുണ ഉൾപ്പെടുന്നു
 പരീക്ഷണങ്ങൾ ടൈപ്പുചെയ്യുക, ഉദാ. 
 ആക്ടീവ് പാറ്റേണുകൾ, ഒബ്ജക്റ്റ് തരങ്ങൾ അനുസരിച്ചാകാം

എഫ്# ഒബ്ജക്ട് തരം നിർവചനങ്ങൾ ക്ലാസ്, ഘടന, ഇന്റർഫേസ്, എൻയും, അല്ലെങ്കിൽ ഡെലിഗേറ്റ് തരം നിർവചനങ്ങൾ, സി# ൽ കാണുന്ന നിർവചന രൂപങ്ങളുമായി യോജിക്കുന്നു.
/// A simple object type definition
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
എസിൻക്രണസ് പ്രോഗ്രാമിംഗ്
എസിൻക്രണസ് വർക്ക്ഫ്ലോകൾ വഴി എസിൻക്രണസ് പ്രോഗ്രാമിനായി എഫ് # പിന്തുണയ്ക്കുന്നു. ഒരു എസിൻക്രണസ്  വർക്ക്ഫ്ലോ ഒരു  async {...}  ഉള്ളിൽ ഒരു കമാൻഡ് ആയി നിർവചിക്കപ്പെട്ടിട്ടുണ്ട്.
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() }
let!എന്ന വലതുപക്ഷത്തിന്റെ എക്സ്പ്രഷൻ (പ്രതികരണം ലഭിക്കുന്നത്)സൂചിപ്പിക്കുന്നത് ഏകീകൃതമായി ചെയ്യണം എന്നതാണ് പക്ഷെ ഫലം ലഭ്യമാകുമ്പോൾ മാത്രമേ പ്രോഗ്രാമിന്റെ ഫ്ലോ തുടരേണ്ടതുള്ളൂ. മറ്റൊരുവിധത്തിൽ പറഞ്ഞാൽ, കോഡ് ബ്ലോക്കിന്റെ കാഴ്ചപ്പാടിൽ നിന്ന് പ്രതികരണം ലഭിക്കുന്നത് തടയൽ കോൾ ആണെങ്കിൽ, സിസ്റ്റത്തിന്റെ കാഴ്ചപ്പാടിൽ നിന്ന് ത്രെഡ് തടയപ്പെടുകയില്ല, മറ്റ് പ്രവാഹങ്ങൾ പ്രോസസ്സുചെയ്യാൻ ഉപയോഗിച്ചേക്കാം. ഇതിന് ആവശ്യമായ ഫലം ലഭ്യമല്ല. 

Async.RunSynchronouslyഫങ്ഷൻ ആയി പ്രവർത്തിക്കുന്ന എസിങ്ക്(Async) ബ്ലോക്ക് ആയിരിക്കാം. ഒരു async.Parallel ഫങ്ഷൻ ഉപയോഗിച്ച് സമാന്തരമായി നിരവധി എസിങ്ക് ബ്ലോക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും (ഉദാഹരണമായി, എസിങ്ക്ടാസ്ക് ഒരു  എസിങ്ക് ഒബ്ജക്റ്റാണ്) കൂടാതെ പാരലൽ ടാസ്കുകൾ പ്രവർത്തിപ്പിക്കാൻ മറ്റൊരു എസിങ്ക് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു. എഫ്# ലെ പദ വിപര്യയ നിയന്ത്രണം മൂലം ഈ പാറ്റേൺ പിന്തുടരുന്നു.
സമാന്തര പ്രോഗ്രാമിങ്
പാരലൽ പ്രോഗ്രാമിങ്, ഭാഗികമായി Async.Parallel, Async.Start എന്നിവയിലൂടെ സമാന്തരമായി എസിൻക്രണസ് ബ്ലോക്കുകളെ മറ്റ് പ്രവർത്തനങ്ങളിലൂടെ പിന്തുണയ്ക്കുന്നു.

എഫ്# സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ Async.Parallel ഫങ്ഷണൽ പ്രോഗ്രാമിങ് ഓപ്പറേറ്റർമാരെക്കൂടി പിന്തുണയ്ക്കും.  System.Threading.Tasks ടാസ്ക് പ്രോഗ്രാമിങ് മോഡലിന്റെ നേരിട്ടുള്ള ഉപയോഗം,.നെറ്റ് ത്രെഡ് പൂളിന്റെയും .നെറ്റ്(.NET) ത്രെഡുകളുടെയും എഫ് # കോഡ് ഡൈനാമിക് പരിഭാഷ വഴി ജിപിയു(GPU) കോഡ് പോലെയുള്ള ബദൽ സമാന്തര എക്സിക്യൂഷൻ എൻജിനുകൾക്കും നേരിട്ട് ഉപയോഗപ്പെടുത്തുന്നു.

അളവിന്റെ യൂണിറ്റുകൾ
സംഖ്യകളുടെ അളവെടുക്കൽ പരിശോധന യൂണിറ്റുകളെ എഫ്# ടൈപ്പ് സിസ്റ്റം പിന്തുണയ്ക്കുന്നു. ഉപയോക്തൃ കോഡിലെ കുറഞ്ഞ തരം വ്യാഖ്യാനങ്ങൾ ആവശ്യമായ എഫ്# ടൈപ്പ് അനുമാനങ്ങളുമായി അളക്കുന്ന സവിശേഷ യൂണിറ്റുകൾ സംയോജിക്കുന്നു.

മെറ്റാപ്രോഗ്രാംമിങ്ങ്
എഫ്# ഭാഷയ്ക്കുള്ള ഇഷ്ടാനുസൃത ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷകളെ ഉൾപ്പെടുത്തുന്നതിന് മെറ്റാപ്രോഗ്രാംമിങ്ങ് മുഖേനയുള്ള ചില സിന്റാക്സ് കസ്റ്റമൈസ് ചെയ്യാൻ എഫ്#  അനുവദിക്കുന്നു, പ്രത്യേകിച്ച് കമ്പ്യൂട്ടിംഗ് എക്സ്പ്രഷനുകളിലൂടെ.

എഫ് ഷാർപ്പിൽ മെറ്റ പ്രോഗ്രാമിംഗ് ഉദ്ധരണികൾക്കുള്ള ഒരു സവിശേഷത ഉൾക്കൊള്ളുന്നു.ഒരു ഉദ്ധരണി എക്സ്പ്രഷൻ F # എക്സ്പ്രഷനുകളുടെ അമൂർത്ത സിന്റാക്സ് ട്രീ അവതരണത്തിലേക്ക് മൂല്യനിർണ്ണയം ചെയ്യുന്നു. അതുപോലെ, [<reflectedDefinition>] ആട്രിബ്യൂട്ടിനെ ലേബൽ ചെയ്ത നിർവചനങ്ങൾ  ഉദ്ധരണി രൂപത്തിലും ആക്സസ് ചെയ്യാവുന്നതാണ്. എഫ്# ഉദ്ധരണികൾ വഴി എഫ്# കോഡ് ജാവാസ്ക്രിപ്റ്റിലേക്കും ജിപിയു കോഡിലേക്കും കംപൈൽ ചെയ്യുക എന്നീ ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു. (പ്രോഗ്രാമിന്റെ മറ്റ് ഭാഗങ്ങൾ ഉപയോഗിക്കുമ്പോൾ ഉദ്ധരണികൾ തങ്ങളുടെ എഫ്# കോഡ് എക്സ്പ്രഷനുകളെ പ്രതിനിധീകരിക്കുന്നു, ഇത് വാക്യഘടനയുടെ ശരിയായ രീതിയിൽ ഉള്ള എഫ്# കോഡ് ആയിരിക്കണം).

വിവര-സമ്പന്നമായ പ്രോഗ്രാമിംഗ്
എഫ് # ടൈപ്പ് പ്രൊവൈഡേഴ്സ് എന്നറിയപ്പെടുന്ന സ്റ്റാറ്റിക് എക്സ്റ്റൻസിബിൾ ടൈപ്പ് ജനറേറ്റ് വഴി എഫ്# 3.0 ഒരു കംപൈൽ ടൈം മെറ്റാ പ്രോഗ്രാമിങ് സംവിധാനം അവതരിപ്പിച്ചു. എഫ്# ടൈപ്പ് പ്രൊവൈഡറുകൾ എഫ്# കംപൈലറും ടൂളുകളും കമ്പൈലർ സമയത്തു് കമ്പൈലർ ഓൺ-ഡിമാന്റ് ടൈപ്പ് വിവരങ്ങൾ ലഭ്യമാക്കുന്ന ഘടകങ്ങളോടൊപ്പം ദീർഘിപ്പിയ്ക്കുന്നു. ഫ്രീബേസ് നോളഡ്ജ് ഗ്രാഫിൽ ഉൾപ്പെടെ, സ്കേലബിൾ വഴി, ബന്ധിപ്പിച്ച വിവര ഉറവിടങ്ങളിലേക്ക് ശക്തമായി ടൈപ്പ് ചെയ്യുവാൻ എഫ് # ടൈപ്പ് ദാതാക്കൾ ഉപയോഗിയ്ക്കപ്പെട്ടു.

എഫ് # 3.0 ൽ എഫ് # ക്വോട്ടേഷൻ, കംപ്യൂട്ടേഷൻ എക്സ്പ്രഷൻ സവിശേഷതകൾ എന്നിവ ലിങ്ക്(LINQ) അന്വേഷണങ്ങൾ നടപ്പിലാക്കാൻ കൂട്ടിച്ചേർക്കുന്നു. ഉദാഹരണത്തിന്:-
// 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 }
തരം ദാതാക്കൾ, ചോദ്യങ്ങൾ, ശക്തമായ ടൈപ്പ് ചെയ്ത ഫങ്ഷണൽ പ്രോഗ്രാമിങ് എന്നിവ വിവര ശേഖരണ പ്രോഗ്രാമുകൾ എന്ന് അറിയപ്പെടുന്നു.
ഏജന്റ് പ്രോഗ്രാമിംഗ്
ലൈറ്റ് വെയിറ്റ് അസിൻക്രണസ് ഏജന്റുകളുടെ ഇൻ-മെമ്മറി നടപ്പിലാക്കലിലൂടെ ആക്റ്റർ പ്രോഗ്രാമിങ് മോഡലിന്റെ വ്യതിയാനം എഫ്# പിന്തുണയ്ക്കുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോഡ് ഒരു ഏജന്റും പോസ്റ്റുകളും 2 സന്ദേശങ്ങൾ നിർവ്വചിക്കുന്നു:
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)
വികസന ഉപകരണങ്ങൾ
 വിഷ്വൽ സ്റ്റുഡിയോയിൽ പൂർണ്ണമായ സംയോജിത വികസന പരിസ്ഥിതി (ഐ.ഡി.ഇ.)ഉള്ളത് മൈക്രോസോഫ്റ്റിൽ (Microsoft) നിന്നുള്ള വിഷ്വൽ എഫ്# ടൂളുകൾക്കാണ്. ഭാഷാ സേവനം ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, എഫ്# പ്രോജക്റ്റുകളും അതിന്റെ ഡീബഗ്ഗറും സൃഷ്ടിക്കാൻ വിഷ്വൽ സ്റ്റുഡിയോ ഉപയോഗിക്കാം. വിഷ്വൽ എഫ് # ടൂളുകളിൽ ഒരു എഫ്# കോഡ് തയ്യാറാക്കാൻ കഴിയുന്ന ഒരു വിഷ്വൽ സ്റ്റുഡിയോ ഹോസ്റ്റുചെയ്ത റീഡ്-ഇവൽ-പ്രിന്റ് ലൂപ് (ആർഇപിഎൽ) ഇന്ററാറ്റീവ് കൺസോൾ ഉൾപ്പെടുന്നു. മാക്കിനായുള്ള വിഷ്വൽ സ്റ്റുഡിയോ, എഫ്# പ്രോജക്ടുകളെ പൂർണ്ണമായും പിന്തുണയ്ക്കുന്നു.
 ലോനിഡെ (Ionide) എക്സ്റ്റൻഷൻ വഴി എഫ്# നുള്ള പൂർണ്ണ പിന്തുണ വിഷ്വൽ സ്റ്റുഡിയോ കോഡിൽ ഉണ്ട്.
 ഏതൊരു ടെക്സ്റ്റ് എഡിറ്റർ ഉപയോഗിച്ചും എഫ്# വികസിപ്പിക്കാം. 
 ഇമാക്സ്(Emacs) പോലുള്ള എഡിറ്ററുകളിൽ പ്രത്യേക പിന്തുണ നൽകുന്നു.
 ഫേബിൾ പ്രോജക്ട് ( F# |> Babel ശൈലി ആയി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു) - എഫ്# കോഡിനായുള്ള ഒരു ബാക്കെൻഡായി ജാവസ്ക്രിപ്റ്റ് ടാർഗെറ്റുചെയ്യുന്നതിനുള്ള പിന്തുണ നൽകുന്നു.
 വെബ് ഷാപ്പർ  എന്നത് ക്രോസ്-ടയർ ജാവാസ്ക്രിപ്റ്റ്, എഫ്#-ലുള്ള എച്ച്.ടി.എം.എൽ. 5(HTML5) വികസനം എന്നിവയാണ്.
 എഫ്# പ്രോഗ്രാമിംഗിനെ പിന്തുണയ്ക്കുന്ന ഒരു സംയോജിത വികസന ചുറ്റുപാടാണ് മോണോഡെവലപ്(MonoDevelop), ലിനക്സ്, മാക്ഓഎസ്, വിൻഡോസിലും ഉപയോഗിക്കുന്ന വിഷ്വൽ സ്റ്റുഡിയോക്ക്  ഇന്ററാക്റ്റീവ് കൺസോൾ പിന്തുണയുമുണ്ട്.
 ഷാർപ്ഡെവലപ്(SharpDevelop) 3.0 പതിപ്പ് മുതൽ എഫ്# പിന്തുണയ്ക്കുന്നു.
 ക്ലൗഡിനുവേണ്ടി എഫ്# ഉപയോഗിക്കുന്ന ആപ്ലിക്കേഷനുകളുടെ വികസനത്തിന് ഒരു ചട്ടക്കൂടും റൺടൈമും ആണ് എംബ്രേസ്(MBrace).
 ലിങ്ക്പാഡ്(LINQPad) പതിപ്പ് 2.x ൽ നിന്നും എഫ്#നെ പിന്തുണയ്ക്കുന്നു.
 3.0 പതിപ്പ് മുതൽ എഫ്# സെമാരിൻ സ്റ്റുഡിയോ പിന്തുണയ്ക്കുന്നു.
ആപ്ലിക്കേഷൻ ഏരിയകൾ
എഫ്# ഒരു പൊതു ഉദ്ദേശ പ്രോഗ്രാമിങ് ഭാഷയാണ്.
വെബ് പ്രോഗ്രാമിംഗ്
എഫ്# കോഡ് ഒരു സെർവറിലെ നെറ്റീവ് കോഡും ക്ലയന്റിൽ ജാവാസ്ക്രിപ്റ്റ് കോഡുമൊക്കെയായി എഫ്# കോഡ് നടപ്പിലാക്കുന്ന വെബ് ഷാർപ്പർ ചട്ടക്കൂടിന്റെ ഒരു കേന്ദ്ര ഭാഗമാണ്.
അനലിറ്റിക്കൽ പ്രോഗ്രാമിംഗ്
എഫ്# ക്വണ്ടിറ്റേറ്റീവ് ഫിനാൻസ് പ്രോഗ്രാമിംഗിന് ഉപയോഗിക്കുന്നു, ഊർജ്ജ വ്യാപാരം, പോർട്ട്ഫോളിയോ ഒപ്റ്റിമൈസേഷൻ, , മെഷീൻ ലേണിംഗ്,  ബിസിനസ്സ് ഇൻറലിജൻസ്, ഫേസ്ബുക്കിൽ ഉള്ള സോഷ്യൽ ഗെയിമിംഗ് തുടങ്ങിയവക്കായി ഉപയോഗിക്കുന്നു.

2010-ൽ സി #  ഒപ്റ്റിമൈസ് ചെയ്ത ബദലായി എഫ്# നിലയുറപ്പിച്ചു. F # ന്റെ സ്ക്രിപ്റ്റിങ് കഴിവ്, എല്ലാ മൈക്രോസോഫ്റ്റ് പ്രൊഡക്ടുകളോടു ഉള്ള അന്തർഭാഷാ പൊരുത്തം, ഡെവലപ്പർമാർക്കിടയിൽ ജനപ്രിയമാക്കുന്നു. പല ഡെവലപ്പർമാരും എഫ്# അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റങ്ങൾ സൃഷ്ടിക്കുന്നു, കൂടാതെ സി #  WCF സേവനങ്ങൾ ഉപയോഗിക്കുന്നു.
സ്ക്രിപ്റ്റിംഗ്
പ്രധാനമായും ഡെസ്ക്ടോപ്പ് റീഡ്-ഇവൽ-പ്രിന്റ് ലൂപ്പ് (REPL) സ്ക്രിപ്റ്റിങ്ങിനുള്ള സ്ക്രിപ്റ്റിംഗ് ഭാഷയായി എഫ് # ഉപയോഗിക്കാം.
ഓപ്പൺ സോഴ്സ് കമ്മ്യൂണിറ്റി
എഫ് # ഓപ്പൺ സോഴ്സ് സമൂഹത്തിൽ എഫ് # സോഴ്സ് ഫൗണ്ടേഷനും ഗിറ്റ്ഹബിലുള്ള എഫ് # ഓപ്പൺ സോഴ്സ് ഗ്രൂപ്പും ഉൾപ്പെടുന്നു.
അനുയോജ്യത
എഫ്# പരമ്പരാഗതമായ "എംഎൽ(ML) അനുയോജ്യത മോഡ്" നേരിട്ട് ഒകാമൽ(OCaml)ന്റെ വലിയ ഉപസൗരത്തിൽ എഴുതപ്പെട്ട പ്രോഗ്രാമുകൾ നേരിട്ട് സമാഹരിക്കാൻ കഴിയും, ഫങ്റ്റേഴ്സ്, വസ്തുക്കൾ, പോളിമോർഫിക് വേരിയന്റുകൾ അല്ലെങ്കിൽ മറ്റ് കൂട്ടിച്ചേർക്കലുകൾ എന്നിവ ഇല്ലാതെ.
ഉദാഹരണങ്ങൾ
ഏതാനും ചെറിയ സാമ്പിളുകൾ പിന്തുടരുന്നു:
// 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

/// class instantiation
let mrSmith = Person("Smith", 42)
ഫംഗ്ഷണൽ ഭാഷകളുടെ വാക്യഘടന കാണിക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഉദാഹരണം, നോൺ-നെഗറ്റീവ് 32 ബിറ്റ് പൂർണ്ണ സംഖ്യ ഫാക്റ്റോറിയൽ ഫംഗ്ഷൻ, ഇവിടെ എഫ്# ൽ കാണിച്ചിരിക്കുന്നു:
/// Using pattern matching expression
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)

/// For a single-argument functions there is syntactic sugar (pattern matching function):
let rec factorial = function 
    | 0 -> 1 
    | n -> n * factorial (n - 1)

/// Using fold and range operator
let factorial n = [1..n] |> Seq.fold (*) 1
ഇറ്ററേഷൻ(Iteration)ഉദാഹരണങ്ങൾ:
/// 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)
എസിൻക്രണസ് പാരലൽ പ്രോഗ്രാമിങ് സാമ്പിൾ (സമാന്തരമായ സിപിയു, ഐ / ഒ ടാസ്ക്കുകൾ):
/// 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#)
 .നെറ്റ് ഫ്രെയിംവർക്ക്‌
 സ്കാല (പ്രോഗ്രാമിങ് ഭാഷ)
 Clojure
 ഹാസ്കൽ (പ്രോഗ്രാമിങ് ഭാഷ)
 Nemerle

അവലംബം