open System // Gets access to functionality in System namespace.

// Defines a list of names
let names = [ "Peter"; "Julia"; "Xi" ]

// Defines a function that takes a name and produces a greeting.
let getGreeting name = $"Hello, {name}"

// Prints a greeting for each name!
names
|> List.map getGreeting
|> List.iter (fun greeting -> printfn $"{greeting}! Enjoy your F#")

let ExExample a b =  
  let mutable c = 0  
  try  
    c <- (a/b)  
  with  
    | :? System.DivideByZeroException as e -> printfn "%s" e.Message  
  printfn "Rest of the code"  
  
ExExample 10 0  

let TestAgeValidation age  =  
  try  
     if (age<18) then failwith "Sorry, Age must be greater than 18"  
  with  
     | Failure(e) -> printfn "%s" e;   
  printf "Rest of the code"  
TestAgeValidation 10  
Example of InvalidArg keyword
let TestInvalidArgument age =  
 if(age<18) then  
  invalidArg "TestInvalidArgument" ("Sorry, Age must be greater than 18")  
  
TestInvalidArgument 10

let divide (x:int, y:int):int =  
 assert (x>0)  
 let z = (x/y)  
 z  
  
let result = divide(10,2)  
printf "%d" result  

open Arithmetic  
printf "%d" (sub 20 10)

// Using a verbatim string
let xmlFragment1 = @"<book author=""Milton, John"" title=""Paradise Lost"">"

// Using a triple-quoted string
let xmlFragment2 = """<book author="Milton, John" title="Paradise Lost">"""

let str1 = "abc
def"
let str2 = "abc\
def"

printfn "%c" str1[1]

The output is : b.

printfn "%s" str1[0..2]
printfn "%s" str2[3..5]

abc
def

// "abc" interpreted as a Unicode string.
let str1 : string = "abc"
// "abc" interpreted as an ASCII byte array.
let bytearray : byte[] = "abc"B

let function1 x y = x + y                 
  
function1 10 20      // this line results a compiler warning  
      
// changing the code to the following and eliminates the warning  
let result = function1 10 20  
  
// Use this if you are calling the function and don't want the return value  
function1 10 20 |> ignore 

type BaseClass() =  
 class  
  member this.ShowClassName()=  
    printfn "BaseClass"  
 end  
  
type DerivedClass() =   
 class  
  inherit BaseClass()  
  member this.ShowClassName()=  
   printfn "DerivedClass"  
 end  
  
let baseClass = new BaseClass()              
let derivedClass : DerivedClass = new DerivedClass()  
baseClass.ShowClassName()      
derivedClass.ShowClassName()  
let castIntoBaseClass = derivedClass :> BaseClass        // upcasting   
castIntoBaseClass.ShowClassName()  
let castIntoDerivedClass = baseClass :?> DerivedClass   // downcasting  
castIntoDerivedClass.ShowClassName()

// Binding a value:
let identifier-or-pattern [: type] =expressionbody-expression
// Binding a function value:
let identifier parameter-list [: return-type ] =expressionbody-expression

// Non-recursive function definition.
let [inline] function-name parameter-list [ : return-type ] = function-body
// Recursive function definition.
let rec function-name parameter-list = recursive-function-body

let function1 name=   
  name + " FSharp"  
let function2 name =   
   name + " Programming"  
  
let programmingName = function1 >> function2  
let result = programmingName "Hello"  
printf "%s" result  

let function1 name=   
  name + " FSharp"  
let function2 name =   
   name + " Programming"  
  
let result = "Hello" |> function1 |> function2  
printf "%s" result  

let result = (fun a -> a+1) 100  
printf "%d" result  

type InlineClass() =  
  class  
    member inline this.inlineFunction(a) = a*a  
  end  
   
let obj = new InlineClass()  
let result = obj.inlineFunction 2  
printf "%d" result

// Recursive function:
let rec function-nameparameter-list =
    function-body

// Mutually recursive functions:
let rec function1-nameparameter-list =
    function1-body

and function2-nameparameter-list =
    function2-body
...

let rec fib n =
    match n with
    | 0 | 1 -> n
    | n -> fib (n-1) + fib (n-2)

Methods are implicitly recursive within the type they are defined in, meaning there is no need to add the rec keyword. For example :

type MyClass() =

    member this.Fib(n) =

        match n with

        | 0 | 1 -> n

        | n -> this.Fib(n-1) + this.Fib(n-2)

Let bindings within classes are not implicitly recursive, though. All let-bound functions require the rec keyword.

match expression with
| pattern [ when condition ] -> result-expression
...

type DoBindingClass() =   
 class  
  do printf "Hello FSharp"     
 end  
new DoBindingClass()  

let a:int = 10  
printf "%d" a

let f a b = a + b + 100

// Type annotations on a parameter.
let addu1 (x : uint32) y =
    x + y

// Type annotations on an expression.
let addu2 x y =
    (x : uint32) + y

let addu1 x y : uint32 =
   x + y

let replace(str: string) =
    str.Replace("A", "a")

let makeTuple a b = (a, b)

'a -> 'b -> 'a * 'b

let x : int = 5

let b : byte = byte x

type Color =
    | Red = 1
    | Green = 2
    | Blue = 3

// The target type of the conversion cannot be determined by type inference, so the type parameter must be explicit.
let col1 = enum<Color> 1

// The target type is supplied by a type annotation.
let col2 : Color = enum 2

let col3 = enum<Color> 3

// Error: types are incompatible
let col4 : Color = enum 2u

#SomeType

'T when 'T :> SomeType

let iterate1 (f : unit -> seq<int>) =
    for e in f() do printfn "%d" e
let iterate2 (f : unit -> #seq<int>) =
    for e in f() do printfn "%d" e

// Passing a function that takes a list requires a cast.
iterate1 (fun () -> [1] :> seq<int>)

// Passing a function that takes a list to the version that specifies a
// flexible type as the return value is OK as is.
iterate2 (fun () -> [1])

val concat: sequences:seq<#seq<'T>> -> seq<'T>

let list1 = [1;2;3]
let list2 = [4;5;6]
let list3 = [7;8;9]

let concat1 = Seq.concat [ list1; list2; list3]
printfn "%A" concat1

let array1 = [|1;2;3|]
let array2 = [|4;5;6|]
let array3 = [|7;8;9|]

let concat2 = Seq.concat [ array1; array2; array3 ]
printfn "%A" concat2

let concat3 = Seq.concat [| list1; list2; list3 |]
printfn "%A" concat3

let concat4 = Seq.concat [| array1; array2; array3 |]
printfn "%A" concat4

let seq1 = { 1 .. 3 }
let seq2 = { 4 .. 6 }
let seq3 = { 7 .. 9 }

let concat5 = Seq.concat [| seq1; seq2; seq3 |]

printfn "%A" concat5

seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]

(element, ... , element)
struct(element, ... ,element )

[<StructuralEquality; StructuralComparison>]
[<Struct>]
type ValueOption<'T> =
    | ValueNone
    | ValueSome of 'T

let tryParseDateTime (s: string) =
    match System.DateTime.TryParse(s) with
    | (true, dt) -> ValueSome dt
    | (false, _) -> ValueNone

let possibleDateString1 = "1990-12-25"
let possibleDateString2 = "This is not a date"

let result1 = tryParseDateTime possibleDateString1
let result2 = tryParseDateTime possibleDateString2

match (result1, result2) with
| ValueSome d1, ValueSome d2 -> printfn "Both are dates!"
| ValueSome d1, ValueNone -> printfn "Only the first is a date!"
| ValueNone, ValueSome d2 -> printfn "Only the second is a date!"
| ValueNone, ValueNone -> printfn "None of them are dates!"
As with Options, the naming convention for a function that returns ValueOption is to prefix it with try.

val defaultValueArg : arg:'T voption -> defaultValue:'T -> 'T

F# List Example
let list = [1;2;3;4;5;6;7;8;9]  
for i  in list do  
 printfn "%d" i  

let arr = [| 1; 2; 3; 4; 5; |]               // Creating and initializing array  
for i = 0 to arr.Length-1 do                // Traversing of array  
  printfn "%d" arr.[i]  

You can create sequence expression like following. Here, we have used Seq.iter () function to iterate sequence. We can also use for loop or array format specifier to iterate sequence elements.

let seq1 =  
 seq { 0 .. 10 }  
Seq.iter(fun a->printf " %d" a)seq1

let refVariable = ref 50  
printf "%d" refVariable.Value

type Student (id,name)=   
 class  
  member x.show =   
  printf "%d \n%s" id name   
  
 end  
let a = new Student (12,"FSharp")  
a.show 

type Employee(name) =   
 class  
  do printf "%s" name  
 end  
let e = new Employee("FSharp")

type Employee(id,name) as this =  
    let id = id  
    let name = name  
    do this.Display()           // This is how we can use self(this) object  
    member this.Display() =  
        printf "%d %s" id name  
let e =new Employee(100, "Ramana")

type Account(accno,name) = class  
 static let rateOfInterest = 8.8  
 member this.display()=  
  printfn "%d %s %0.2f" accno name rateOfInterest   
end  
let a1 = new Account(101,"Rajkumar")  
let a2 = new Account(102, "john")  
a1.display()  
a2.display() 

type MyDerived(...) =
    inherit MyBase(...)

// Abstract class syntax.
[<AbstractClass>]
type [ accessibility-modifier ] abstract-class-name =
[ inherit base-class-or-interface-name ]
[ abstract-member-declarations-and-member-definitions ]

// Abstract member syntax.
abstract member member-name : type-signature

type Employee() =  
 class  
  abstract ShowName : unit -> unit  
  default this.ShowName() = printfn"This is base class method"  
 end   
type Manager() =  
 class  
  inherit Employee()  
  override this.ShowName() = printf "This is derived class method"  
 end  
  
let employee = new Employee()  
let manager = new Manager()  
employee.ShowName()  
manager.ShowName()

// Overloading an operator as a class or record member.
static member (operator-symbols) (parameter-list) =
    method-body
// Overloading an operator at the global level
let [inline] (operator-symbols) parameter-list = function-body

type IEmployee =  
   abstract member ShowName : unit -> unit  
type Manager(id:int, name:string) =  
   interface IEmployee with  
      member this.ShowName() = printfn "Id = %d \nName = %s" id name  
  
let manager = new Manager(100,"RajKumar")  
//manager.ShowName()    // error: you can't directly access interface abstract method by using class object.  
// so, we need to upcast class type object to interface type by using :> operator.  
(manager :> IEmployee).ShowName()

type Deligate() =  
  static member mul(a : int, b : int) = a * b  
  member x.Mul(a : int, b : int) = a * b  
type Multiply = delegate of (int * int) -> int  
  
let getIt (d : Multiply) (a : int) (b: int) =  
   d.Invoke(a, b)  
let d : Multiply = new Multiply( Deligate.mul )  
for (a, b) in [(5, 8) ] do  
  printfn "%d * %d = %d" a b (getIt d a b)

Signature file named as signature.fsi
namespace FSharpPrograms  
  module Arithmetic =  
    val add : int * int -> int  
    val sub : int * int -> int  

open System  
Console.WriteLine("Hello, this is F# here.") 

let x = 10
let result = lazy (x + 10)
printfn "%d" (result.Force())

Lazy evaluation, but not the Lazy type, is also used for sequences.

let add x y  = x+y  
let result = lazy (add 10 10)  
printfn "%d" (result.Force())

open System.Diagnostics
open System.Runtime.CompilerServices
open System.Runtime.InteropServices

type Tracer() =
    member _.DoTrace(message: string,
                      [<CallerMemberName; Optional; DefaultParameterValue("")>] memberName: string,
                      [<CallerFilePath; Optional; DefaultParameterValue("")>] path: string,
                      [<CallerLineNumber; Optional; DefaultParameterValue(0)>] line: int) =
        Trace.WriteLine(sprintf $"Message: {message}")
        Trace.WriteLine(sprintf $"Member name: {memberName}")
        Trace.WriteLine(sprintf $"Source file path: {path}")
        Trace.WriteLine(sprintf $"Source line number: {line}")

dotnet fsi [options] [ script-file [arguments] ]
The file extension for F# script files is .fsx.