F# Introduction
F# is a multi-paradigm .NET language explicitly
designed to be an ML suited to the .NET environment. or, F# is a functional
programming language that runs on Microsoft's Common Language Runtime and the
.NET Framework. F# programming is basically a combination of three Functional
Programming as well as Imperative and Object Oriented Programming Concepts. The
first paradigm is Functional programming. The second paradigm is widely
adopted Object oriented programming. The third paradigm supported by F#
is Language oriented programming.
Data Types In F#
Here, we will describes the types that are used
in F#.
Primitive Types in F# ( Fundamental Data
Types of F#)
Some types are considered primitive types, such
as the Boolean type bool and integral and floating point types of various sizes,
which include types for bytes and characters. these are also called Fundamental
Data Types of F#.
The below table defines the Primitive Types of F#.
Data Type Name | F# type | Example | Size |
Short | int16 | 10s | 2 byte with a sign bit |
Unsigned Short | uint16 | 80us | 2 byte with no sign bit |
Unsigned int | uint32 | 456u | 4 byte with no sign bit |
Unsigned long | uint64 | 9999999ul | 8 byte with no sign bit |
Single | float32 or single | 2.0f, 2.02f, 2.02e20 | 4 byte with a sign bit |
Native int | nativeint | 456n | Size is platform specific |
Unsigned Native int | unativeint | 456un | Size is Platform specific |
Decimal | decimal | 456m | Maps to System.Decimal |
Big number | bignum | 456I | Maps to Microsoft.FSahrp.Math.BigInt |
Other Data Types of F#
These data type are the built in data types in the language, which includes tuples, lists, arrays, sequences, records, and
discriminated unions.
Tuples
A tuple is defined as a comma separated
collection of values. For example, (8, "hi")
is a 2-tuple with the type (int * string)
.
Tuples are extremely useful for creating ad hoc data structures which group
together related values. or, A tuple is a grouping of unnamed but ordered
values, possibly of different types.
For example
Tuple of two integers.
(5, 6)
Names of Tuple Types
When you write out the name of a type that is a tuple, you use the * symbol to separate elements. For a tuple that consists of two int,
such as (5,6) the type would be written as follows.
int *int
Triple of strings
("Mical","Manoj","Gray")
Names of Tuple Types
String* String*string*
Tuple that has mixed types.
( "one", "1", "2.0" )
Names of Tuple Types
String*int*float
Records
A record is similar to a tuple, except that it contains
named fields. F# record types are a simple named type. You can create one or
more variables in a record. When you need to access the record you can access
the complete record or one of its members individually.
The syntax to create a record is:
type recordName = { [ fieldName : dataType ] + }
Example:
type website ={ Title : string; Url : string; view : int }
Lists
List data types
are ordered, immutable series of elements all of the
same type. A F# list is a typical linked
list type. It can be either a empty list or a cell containing a value or a
reference to the tail, which is itself a list. Lists in F# is an immutable and
ordered series of elements.
Example
let
list456 = [ 4; 5; 6 ]
Property of the list
The below example defines the Properties of the
List:
let
definelist = [ 4; 5; 6 ]
// Length
Properties
printfn
"list1.Length is %d" (definelist.Length)
// Head
Properties
printfn
"list1.Head is %d" (definelist.Head)
// Tail
Properties
printfn
"list1.Tail.Head is %d" (definelist.Tail.Head)
// Item
Properties
printfn
"list1.Item(1) is %d" (definelist.Item(1))
OUTPUT
Discriminated union
Discriminated unions are used
to create well defined type hierarchies and hierarchical data types. This data
type is used for showing a data type that can store one of several options. The
example of a discriminated union is an Abstract Syntax Tree. This data type is
useful for heterogeneous data. This data type has a finite number of distinct
alternative representations. F# discriminated unions are type safe and work with
Pattern matching.
Example
type
area =
| Right
| Left
| Top
| Bottom
member this.ToLatin() =
match this
with
| Right ->
"Wand"
| Left ->
"Coin"
| Top ->
"Cup"
| Bottom ->
"Sword"
> let card = Right;;
val
card : Suit = Right
> card.ToLatin()
val
it : string = "Wand"
> let card2 =Top
val
card2 : Suit = Top
> card2.ToLatin()
val
it : string = "Cup"
Sequence
A sequence is a
logical series of elements all of one type. Sequences are particularly useful
when you have a large, ordered collection of data but do not necessarily expect
to use all the elements. Individual sequence elements are computed only as
required, so a sequence can provide better performance than a list in situations
in which not all the elements are used.
For example:
The simplest form specifies a range. For example,
seq { 2 .. 10 } creates a sequence that contains five elements, including the
endpoints 2 and 10. You can also specify an increment (or decrement) between two
double periods. For example, the following code creates the sequence of
multiples of 20:
seq { 0 .. 20 .. 100 }
Variables
To declare a variable, use the let operator, followed by a name for the variable and assign a value to it using the assignment operator "=". The Syntax
for declaring a Variable is:
Defining a integer variable
let a = 5;
Example
let
a = 5;
printfn
"%d"a;
OUTPUT
Example
let
x = 6
let
y = 5
let
z = x* y
printfn
"a: %i" x
printfn
"b: %i" y
printfn
"c: %i" z
OUTPUT