F Sharp (programming language)

F# (pronounced F sharp) is a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. It is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but can also generate JavaScript and graphics processing unit (GPU) code.

F# is developed by the F# Software Foundation, Microsoft and open contributors. An open source, cross-platform compiler for F# is available from the F# Software Foundation. F# is a fully supported language in Visual Studio and JetBrains Rider. Plug-ins supporting F# exist for many widely used editors including Visual Studio Code, Vim, and Emacs.

F# is a member of the ML language family and originated as a .NET Framework implementation of a core of the programming language OCaml. It has also been influenced by C#,
Python, Haskell, Scala and Erlang.

History

Versions

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, UK. The language was originally designed and implemented by Don Syme, according to whom in the fsharp team, they say the F is for "Fun".
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.

Language overview

Functional programming

While supporting object-oriented features available in C#, F# is a strongly typed functional-first language with a large number of capabilities that are normally found only in functional programming languages. Together, these features allow F# programs to be written in a completely functional style and also allow functional and object-oriented styles to be mixed.

Examples of functional features are:

* Everything is an expression
* Type inference (using Hindley–Milner type inference)
* Anonymous functions with capturing semantics (i.e., closures)
* Immutable variables and objects
* Lazy evaluation support
* Higher-order functions
* Nested functions
* Currying
* Pattern matching
* Algebraic data types
* Tuples
* Monad pattern support (called ''computation expressions'')
* Tail Call Optimisation

F# is an expression-based language using eager evaluation and also in some instances lazy evaluation. Every statement in F#,
including if expressions, try 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 unit. F# uses the let keyword for binding values to a name. For example:

let x = 3 + 4

binds the value 7 to the name x.

New types are defined using the type keyword. For functional programming, F# provides ''tuple'', ''record'', ''discriminated union'', ''list'', ''option'', and ''result'' types. A ''tuple'' represents a set of ''n'' values, where ''n'' ≥ 0. The value ''n'' is called the arity of the tuple. A 3-tuple would be represented as (A, B, C), 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 during execution.

A ''record'' is a type where the data members are named. Here is an example of record definition:

type R =

Records can be created as . The with keyword is used to create a copy of a record, as in , 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 notation (:: is the cons operator) or a shorthand as . An empty list is written []. The ''option'' type is a discriminated union type with choices Some(x) or None. F# types may be generic programming, 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 (computer science) using the >> and << operators.

F# provides ' that define a sequence seq , list ... /code> or array
_seq_

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_ Generator_(computer_programming), 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_'._Sequence_expressions,_asynchronous_computations_and_queries_are_particular_kinds_of_computation_expressions._Computation_expressions_are_an_implementation_of_the_ monad_pattern.


_Imperative_programming

F#_support_for_imperative_programming_includes
*_for_ loops
*_while_ loops
*_ arrays,_created_with_the_ Associative_array, hash_table,_created_with_the_dict__..._/code>_syntax_or_System.Collections.Generic.Dictionary<_,_>_type.
Values_and_record_fields_can_also_be_labelled_as_mutable._For_example:

//_Define_'x'_with_initial_value_'1'
let_mutable_x_=_1
//_Change_the_value_of_'x'_to_'3'
x_<-_3

Also,_F#_supports_access_to_all_CLI_types_and_objects_such_as_those_defined_in_the_System.Collections.Generic_namespace_defining_imperative_data_structures.

_Object-oriented_programming

Like_other__Common_Language_Infrastructure_(CLI)_languages,_F#_can_use_CLI_types_through_object-oriented_programming.__F#_support_for_object-oriented_programming_in_expressions_includes:
*_Dot-notation,_e.g.,_
*_Object_expressions,_e.g.,_
*_Object_construction,_e.g.,_
*_Type_tests,_e.g.,_
*_Type_coercions,_e.g.,_
*_Named_arguments,_e.g.,_
*_Named_setters,_e.g.,_
*_Optional_arguments,_e.g.,_

Support_for_object-oriented_programming_in_patterns_includes
*_Type_tests,_e.g.,_
*_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

_Asynchronous_programming

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_

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

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_tree_representation_of_the_F#_expressions._Similarly,_definitions_labelled_with_the_ lt;ReflectedDefinition>/code>_attribute_can_also_be_accessed_in_their_quotation_form._F#_quotations_are_used_for_various_purposes_including_to_compile_F#_code_into_JavaScript_

JavaScript_(),_often_abbreviated_as_JS,_is_a__programming_language_that_is_one_of_the_core_technologies_of_the__World_Wide_Web,_alongside_HTML_and_CSS._As_of_2022,_98%_of__websites_use_JavaScript_on_the__client_side_for__webpage_behavior,_of_...