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()

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

let ShowName() = 
 printf "Hello FSharp"
ShowName()

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

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

let add a b =      //Here, all parameters are inferred to int because of passing values during calling
 a+b               // Return type of this function is int because the type of this expression is int.
printf "%d" (add 10 20)

let (id,name) = (1, "Fsharp")
printfn "%d" id
printfn "%s" name  

let TupleExample a b = 
 let c = a+b
 let d = a-b
 (c, d)
 
let tupleValues = TupleExample 50 10 
printf "%A" tupleValues

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]

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

let sub a b =
 if(a>b) then
  Some(a-b)
  else None
printf "%A" (sub 20 10)

let genericFunctionExample<'T> x y =
    printfn "%A %A" x y

genericFunctionExample 1 2

type RecordExample = { x : float; y: float; z: float; }
let getRecordValues = { x = 2.0; y = 1.0; z = 0.0; }
printf "%A\n" getRecordValues             // Access all values of record
printf "%f" getRecordValues.x    // Access individual values of record

type Year =
   | January = 0
   | Fabruary = 1
   | March = 2
   | April = 3

// Use of an enumeration.
let monthName = enum(3)
printf "%A" monthName
let monthLiteral : Year = Year.January
let n = int monthLiteral
printf "\n%d" n

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

type Book = struct
   val title : string
   val author: string
   val price : float
   new (title, author, price) =           // Constructor
      {title = title; author = author; price = price;}
end
let book = new Book("FSharp Programming", "Chris Smith", 100.0)   // Calling Constructor
printfn "Title  : %s " book.title
printfn "Author : %s"  book.author
printfn "Price  : $%0.2f"  book.price   

type Calcualte =  
    | Add of val1 : int * val2 : int  
    | Multiply of val1 : int * val2 : int  
  
let compute vall =  
   match vall with  
     | Add (val1, val2) -> val1+val2  
     | Multiply (val1, val2)->val1*val2  
  
let addition = compute (Add(10,10))  
let multiplication = compute (Multiply(2,5))  
  
printf "Addition = %d\nMultiplication = %d" addition multiplication  

let objectName = new ClassName()

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, "Rajkumar")

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 Employee(name:string) =
 class
  member this.ShowName() = printf"Name = %s\n" name
 end
type Manager(name,salary:int) =
 class
  inherit Employee(name)
  member this.ShowSalary() = printf"Salary = $%d" salary
 end
let manager = new Manager("Rajkumar",10000)
manager.ShowName()
manager.ShowSalary()

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()

[]
type AbstractClass() = 
 class
  abstract member ShowClassName : unit -> unit
 end
type DerivedClass()  = 
 class
  inherit AbstractClass()
  override this.ShowClassName() = printf "This is derived class."
 end

let a = new DerivedClass()
a.ShowClassName()

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 ClassExtension() =
 member this.ShowBefore() = printfn"Class before extension"

// Define type extension.
type ClassExtension with
 member this.ShowAfter() = printfn"Class after extension"

let classExtension = new ClassExtension()
classExtension.ShowBefore()
classExtension.ShowAfter()

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)

let ex =
 {
      new System.Exception() with member x.ToString() = "Hello FSharp" 
 }
printfn "%A" ex

let ExExample a b =
 let mutable c = 0
 c <- (a/b)
 printfn "Rest of the code"

ExExample 10 0

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

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)

open System.IO
let ReleaseFile fileName content =
    using (System.IO.File.CreateText(fileName)) ( fun textFile ->
        textFile.WriteLine("{0}", content.ToString() )
    )

ReleaseFile "file/textFile.txt" "This is a text file. \nIt contains data."

open System
[]
let updateSystem() = 
 printf "updating..."

updateSystem

namespace FSharpPrograms
  module Arithmetic =
    val add : int * int -> int
    val sub : int * int -> int

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

type name = 
| case-identifier1 [of [ fieldname1 : ] type1 [ * [ fieldname2 : ] 
type2 ...]
| case-identifier2 [of [fieldname3 : ]type3 [ * [ fieldname4 : ]type4 ...]

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

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