Defining a CLIMutable attribute in F# code

[<CLIMutable>]
type R =
  { X : int; Y : int }

// R2 does not have default constructor
type R2 =
  { X : int; Y : int }

C# code invoking the CLIMutable record

var x = new R();
var x2 = new R(0, 2);
var y = new R2(0, 2);
// var y2 = new R2();   //does not compile

// define the type provider
type Demographics = Microsoft.FSharp.Data.TypeProviders.ODataService<ServiceUri =
    "https://api.datamarket.azure.com/Uk.Gov/TravelAdvisoryService/">
let ctx = Demographics.GetDataContext()

// set the credentials
ctx.Credentials <- System.Net.NetworkCredential(<liveID>, <id>)

// define a serializable record
[<CLIMutable>]
type NewsRecord = { Title : string; Summary : string }

// query the latest news
let latestNews = query {
    for n in ctx.LatestTravelNewsFromFco do
    select { NewsRecord.Title = n.Title; NewsRecord.Summary = n.Summary}
}

let news = latestNews |> Seq.toArray

// deserialize from xml
let deserialize<'T> (fileName:string) =
    let reader = System.Xml.Serialization.XmlSerializer(typeof<'T>)
    use file = new System.IO.StreamReader(fileName)
    let fileData = reader.Deserialize(file) :?> 'T
    fileData

// serialize data
let serialize data (fileName:string) =
    let writer = System.Xml.Serialization.XmlSerializer(data.GetType())
    use file = new System.IO.StreamWriter(fileName)
    writer.Serialize(file, data)

//serialize the data
serialize news "myLocalNews.xml"

// deserialize the file
let data = deserialize<NewsRecord array> "myLocalNews.xml"

// structural comparison to make sure the data is the same
let isEqual = news = data

OR function with tuple pattern matching

let orFunction (x, y) =
    match x, y with
        | true, true -> true
        | true, false -> true
        | false, true -> true
        | false, false -> false

Simplified OR function with tuple pattern matching

let orFunction2 (x, y) =
    match x, y with
        | false, false -> false
        | _, _ -> true

let f x =
    let dict = System.Collections.Generic.Dictionary()
    dict.[0] <- "0"
    dict.[1] <- "1"

    match dict.TryGetValue x with
    | true, v -> sprintf "found %A mapped to %A" x v
    | false, _ -> "cannot find"

printfn "%A" (f 0)
printfn "%A" (f 1)
printfn "%A" (f 2)

Execution result

"found 0 mapped to "0""
"found 1 mapped to "1""
"cannot find"

>     let orFunction (x, y) =
        match x, y with
        | true, true -> true
        //| true, false -> true // miss one pattern
        | false, true -> true
        | false, false -> false;;

          match x, y with
  --------------^^^^

stdin(2,15): warning FS0025: Incomplete pattern matches on this expression. For example,
the
 value '(_,false)' may indicate a case not covered by the pattern(s).

let arrayLength array =
    match array with
    | [| |] -> 0
    | [| _ |] -> 1
    | [| _; _ |] -> 2
    | [| _; _; _ |] -> 3
    | _ -> Array.length array

let rec listLength list =
    match list with
    | head :: tail -> 1 + (listLength tail)
    | [] -> 0

let list = [1;2;3;4;]
match list with
| h0::h1::t -> printfn "two elements %A %A and tail %A" h0 h1 t
| _ -> ()

let objList = [box(1); box("a"); box('c')]
match objList with
| [:? int as i;
   :? string as str;
   :? char as ch] ->
       printfn "values are %A %A %A" i str ch
| _ -> ()

Using an identifier pattern to test and extract an option value

let extractOption x =
    match x with
    | Some a -> printfn "option has value %A" a
    | None -> printfn "option has no value"

Using a NULL pattern to convert a nullable .NET value to an F# option

let toOption x =
    match x with
    | null -> None
    | _ -> Some x

Using an identifier pattern for a discriminated union

type Shape =
    | Circle of double
    | Triangle of double * double * double
    | Rectangle of double * double

let getArea shape =
    match shape with
    | Circle(r) -> r * r * System.Math.PI
    | Triangle(a, b, c) ->
        let s = (a + b + c) / 2.
        sqrt s * (s - a) * (s - b) * (s - c)
    | Rectangle(a, b) -> a * b

Using a record pattern

type Point2D = { x : float; y: float }

let isOnXAxis p =
    match p with
    | { Point2D.x = 0.; Point2D.y = _ } -> true
    | _ -> false

type Currency =
    | USD of decimal
    | CAD of decimal

    // extend the DU type with the + and - operators
    with
        static member (+) (x:Currency, y:Currency) =
            match x, y with
                | USD(a), USD(b) -> USD(a+b)
                | CAD(a), CAD(b) -> CAD(a+b)
                | _ -> failwith "cannot add different unit value"

        static member (-) (x:Currency, y:Currency) =
            match x,y with
                | USD(a), USD(b) -> USD(a - b)
                | CAD(a), CAD(b) -> CAD(a - b)
                | _ -> failwith "cannot add different unit value"

// perform currency add and minus operations
try
    printfn "result = %A" (USD(1m) + USD(11m))
    printfn "result = %A" (CAD(1m) - CAD(11m))

    // this line generates an exception
    printfn "result = %A" (USD(100m) - CAD(10m))
with
    | _ as e -> printfn "%A" e

Execution result

result = USD 12M
result = CAD -10M
System.Exception: cannot add different unit value

type MyRecord = { X : int list; Y : string }
type MyRecord2 = { XX : int; YY : string; Z : int }

let rr = { X = [100; 200; 300]; Y = "aa" }
let r0 = { X = [100; 200; 3]; Y = "aa" }
let r1 = { XX = 1; YY = "bb"; Z = 9 }

match r1 with
    | rr -> "a"
    | _ -> "b"

type MyRecord = { X : int list; Y : string }
type MyRecord2 = { XX : int; YY : string; Z : int }

let r1 = { XX = 1; YY = "bb"; Z = 9 }
let r2 = { XX = 2; YY = "r2"; Z = 10 }

match r2 with
    | {YY = "bb"} -> """r1 is matched with YY="bb" """
    | _ -> "others"

And pattern used to test a point

let testPoint2 point =
    match point with
    | x, y & 0, 0 -> "original point"
    | x, y & 0, _ -> "on x axis"
    | x, y & _, 0 -> "on y axis"
    | _ -> "other"

Or pattern

let testPoint3 point =
    match point with
    | x, y & (0, 0) -> "original point"
    | x, y & (0, _ | _, 0) -> "on axis"
    | _ -> "other"

let testPoint4 point =
    match point with
    | (x, y) & (0, 0) -> "original point"
    | (x, y) & (0, _) | (x, y) & (_, 0) -> "on axis"
    | _ -> "other"

let testPoint tuple =
    match tuple with
    | x, y when x = y -> "on the line"
    | x, y when x > y -> "below the line"
    | _ -> "up the line"

let testType (x:obj) =
    match x with
    | :? float as f -> printfn "float value %f" f
    | :? int as i -> printfn "int value %d" i
    | _ -> printfn "type cannot process"

open System

// initialize a Choice<int,int>
let a : Choice<int, int> = Choice2Of2 1

// match against the choice
let f x =
    match x with
        | Choice1Of2 e -> printfn "value is %A" e
        | Choice2Of2 e -> printfn "value is %A" e

f a

Execution result

value is 1

// define a single-case active pattern
let (| Remainder2 |) x = x % 2

// use Remainder pattern to check even/odd number
let checkNumber x =
    match x with
        | Remainder2 0 -> "even number"
        | Remainder2 1 -> "odd number"

open System.Collections.Generic

let (|SafeDict|) (d : Dictionary<_, _>) =
    if d = null then Dictionary<_, _>()
    else d

let tryFind (SafeDict dic) key =
    if dic.ContainsKey key then
        Some dic.[key]
    else None

// define partial active patterns
let (|LessThan10|_|) x = if x < 10 then Some x else None
let (|Btw10And20|_|) x = if x >= 10 && x < 20 then Some x else None

let checkNumber2 x =
    match x with
    | LessThan10 a -> printfn "less than 10, the value is %d" a
    | Btw10And20 a -> printfn "between 10 and 20, the value is %d" a
    | _ -> printfn "that's a big number %d " x

let (|FirstQuarter|SecondQuarter|ThirdQuarter|FourthQuarter|) (date:System.DateTime) =
    let month = date.Month
    match month with
    | 1 | 2 | 3 -> FirstQuarter month
    | 4 | 5 | 6 -> SecondQuarter month
    | 7 | 8 | 9  -> ThirdQuarter month
    | _ -> FourthQuarter month

let newYearResolution date =
    match date with
    | FirstQuarter _-> printfn "New Year resolution: lose 10 lbs this year!"
    | SecondQuarter _-> printfn "beef is good for summer BBQ?"
    | ThirdQuarter _ -> printfn "maybe I should diet?"
    | FourthQuarter _-> printfn "Mom's apple pie is wonderful!"

open System.Text.RegularExpressions

// define the parameterized active pattern
let (|RegexMatch|_|) (pattern:string) (input:string) =
    let regex = Regex(pattern).Match(input)
    if regex.Success then Some(List.tail [ for x in regex.Groups -> x.Value])
    else None

let parsePhoneNumber str =
    match str with
    | RegexMatch "(d{3})-(d{3})-(d{4})" out -> System.String.Join("", out)
    | RegexMatch "(d{3})-(d{3})(d{4})" out ->  System.String.Join("", out)
    | _ -> "Not supported format"

// two statements below show 4251231234
parsePhoneNumber "425-123-1234"
parsePhoneNumber "425-1231234"

// this format does not parse and shows "Not supported format"
parsePhoneNumber "(425)123-1234"

let (|Divisible|_|) x y=
    if y % x = 0 then
        Some Divisible
    else
        None

let f2 = function
    |  Divisible 2 & Divisible 3 -> "divisible by 6"
    | _ -> "other"

f2 6

open System

let exceptionCatch() =
    try
        let a = 3 / 0     //divide by zero exception
        printfn "%d" a
    with
    | :? DivideByZeroException -> printfn "divided by zero"

exceptionCatch()

// try...finally sample
try
    <some exception thrown>
finally
    printfn "ignore the exception and perform some clean up"

// try...catch...finally
try
    try
        <some exception thrown>
    with _ -> printfn "catch the exception"
finally
    printfn "finally section executing..."

open System

try
    failwith "this is an exception"
with :? Exception as e -> printfn "the exception msg is %s" e.Message

try
    failwithf "this is an exception generated at %A" DateTime.Now
with _  as e -> printfn "the exception msg is %s" e.Message

open System

try
    raise (Exception("raise exception"))
with _ -> printfn "catch exception"

try
    try
        raise (Exception("raise exception"))
    with _ -> printfn "catch exception"; reraise()
with _ -> printfn "catch reraise exception"

let demoInvalidArgumentAndOperation arg0 arg1 =
    if arg0 = null then
        nullArg "arg0 is null"
    if arg1 = System.String.Empty then
        invalidArg "arg1" "arg1 is empty string"
    invalidOp "sorry, this is an invalid operation"

//define an exception type with int*int tuple
exception MyException of int * int

try
    raise (MyException(1, 2))
with _ as e -> printfn "%A" e

//define an exception type with int*int tuple
exception MyException of int * int

try
    raise (MyException(1, 2))
with :? MyException as e -> printfn "exception data is %d and %d" e.Data0 e.Data1

let F x = float x + 1.0
let inline F_inline x = float x + 1.0

Execution result in FSI

val F : int -> float
val inline F_inline :
   ^a -> float when  ^a : (static member op_Explicit :  ^a -> float)

let inline f x = x + 1
type InlineSample() =
    member inline this.F x = x + 1
    static member inline F x = x + 1

open System.Threading
open System

// define a thread function body
let thread() =
    [1..5]
    |> Seq.iter (fun _ -> Thread.Sleep 1000;
                              printfn "%A from thread %d"
                                DateTime.Now
                                Thread.CurrentThread.ManagedThreadId)

// create a new thread
let spawn() =
    let thread = Thread thread
    thread.Start()

spawn()
spawn()

C# lock

lock (o)
{
    myCode();
}

F# lock

lock o (fun () ->
              SomeCode()
         )

open System
open System.Threading

let synRoot = ref 0
let presenterFunction() =
    let id = Thread.CurrentThread.ManagedThreadId
    printfn "I (%d) starting, please do not interrupt..." id
    Thread.Sleep 1000
    printfn "I (%d) finished, thank you!" id

let longTalk () =
    lock(synRoot) (fun () -> presenterFunction())

ThreadPool.QueueUserWorkItem(fun _ -> longTalk()) |> ignore
ThreadPool.QueueUserWorkItem(fun _ -> longTalk()) |> ignore
ThreadPool.QueueUserWorkItem(fun _ -> longTalk()) |> ignore

type AsyncSample(l:seq<int>) =
    member this.IsIncreasing() =
        // declare a reference cell to hold the shared variable
        let num = ref 0

        // safely increase the shared variable
        let inc () = lock(num) ( fun _ -> num := (!num) + 1 )

        // make the sequence into a sequence containing a number of small two-element
sequences
        let windowedList = l |> Seq.windowed 2

        // the compare function
        let compare s =
            async {
                let list = List.ofSeq s
                let [ x; y ] = list   // the two-element list can be assigned to x and y

                // if x < y, then increase the shared variable; otherwise, do nothing
                if x < y then inc()
                else ()
                }

        // split the sequence into small two-element sequences and execute
        // the function in parallel
        let compute =
            windowedList
            |> Seq.map compare  // can think as map seq of data into seq of functions
            |> Async.Parallel
            |> Async.RunSynchronously

        // compare the shared variable with sequence length
        (!num) + 1 = Seq.length l

let syncRoot = ref 0
lock(syncRoot) ( fun _ ->  printfn "not interleaving printfn" )

type AsyncSample(l:seq<int>) =
    member this.AreAll(compareFunction) =
        // declare a reference cell to hold the shared variable
        let num = ref 0

        // safely increase the shared variable
        let inc () = lock(num) ( fun _ -> num := (!num) + 1 )

        // make the sequence into a sequence containing a number of small two-element
sequences
        let windowedList = l |> Seq.windowed 2

        // the compare function
        let compare s =
            async {
                let list = List.ofSeq s
                let [ x; y ] = list   // the two-element list can be assigned to x and y
                if compareFunction x y then inc()
                else ()
                }

        // split the sequence into small two-element sequences and execute
        // the function in parallel
        let compute =
            windowedList
            |> Seq.map compare  // can think as map seq of data into seq of functions
            |> Async.Parallel
            |> Async.RunSynchronously

        // compare the shared variable with sequence length
        (!num) + 1 = Seq.length l

// create an object with sequence 1 to 10
let asyncObj = AsyncSample(seq { 1..10 })

// pass function "<" to perform the comparison
asyncObj.AreAll(<)

 // rename the mailbox processor to Agent
type Agent<'T> = MailboxProcessor<'T>

// create the agent with async
let agent =
   Agent.Start(fun
mailbox ->
     async { while true do
               let! msg = mailbox.Receive()
               printfn "got message '%s'"
msg } )

// post the message
agent.Post "hello"
agent.Post "world"

// rename the mailbox processor to Agent
type Agent<'T> = MailboxProcessor<'T>

// create agents
let agents =
    [1 .. 100 * 1000]
    |> List.map  (fun i->
       Agent.Start(fun n ->
         async {
            while true do
               let! msg = n.Receive()
               if i % 20000 = 0 then
                   printfn "agent %d got message '%s'" i msg } ))

// post message to all agents
for agent in agents do
    agent.Post "hello"

Execution time

Real: 00:00:02.665, CPU: 00:00:03.375, GC gen0: 26, gen1: 24, gen2: 1

// rename the mailbox processor to Agent
type Agent<'T> = MailboxProcessor<'T>

// event to be raised
let myEvent = new Event<int>()

// current sync context
let syncContext = System.Threading.SynchronizationContext.Current

// create agents
let agents =
    [1 .. 100 * 1000]
    |> List.map  (fun i->
       Agent.Start(fun n ->
         async {
            while true do
               let! msg = n.Receive()
               if i % 30000 = 0 then
                   syncContext.Post( (fun _ -> myEvent.Trigger i), null) } ))

// added event handler
Event.add (fun n-> printfn "%A messages received" n) myEvent.Publish

// post message to all agents
for agent in agents do
    agent.Post "hello"

// rename the mailbox processor to Agent
type Agent<'T> = MailboxProcessor<'T>

// event to be raised
let myEvent = new Event<int>()

let syncContext = System.Threading.SynchronizationContext.Current

// create agents
let agents =
    [-100 * 1000 .. 100 * 1000]
    |> List.map  (fun i->
        use a = new Agent<_>(fun n ->
                 async {
                    while true do
                       let! msg = n.Receive()
                       let result = 100 / i;
                       if i % 30000 = 0 then
                           syncContext.Post( (fun _ -> myEvent.Trigger i), null) } )
        a.Error.Add(fun _ -> printfn "something is wrong")
        a.Start()
        a)

// added event handler
Event.add (fun n-> printfn "%A message received" n) myEvent.Publish

// post message to all agents
for agent in agents do
    agent.Post "hello"

open Microsoft.FSharp.Control

[<Measure>] type USD

// define account state
type AccountState =
    | Overdrawn
    | Silver
    | Gold

// define operations: deposit and withdraw
type Operation =
    | Deposit of decimal<USD>
    | Withdraw of decimal<USD>

// define the account class
type Account() =
    let mutable balance = 0.m<USD>

    // define a MailboxProcessor
    let bank = new MailboxProcessor<Operation>(fun inbox ->
                let rec loop () =
                    async {
                        let! msg = inbox.Receive()
                        match msg with
                            | Deposit n -> balance <- balance + n
                            | Withdraw n -> balance <- balance - n
                        return! loop ()
                    }

                loop ())

    // start the MailboxProcessor instance
    do
        bank.Start()

    // define operations which post the message to MailboxProcessor
    member this.Deposit(args) =
        bank.Post(Deposit(args))
    member this.Withdraw(args) =
        bank.Post(Withdraw(args))

    member this.State
        with get() =
            match balance with
                | _ when balance <= 0.m<USD> -> AccountState.Overdrawn
                | _ when balance > 0.m<USD> && balance < 10000.m<USD> -> AccountState.
Silver
                | _ -> AccountState.Gold
    member this.PayInterest() =
        while bank.CurrentQueueLength > 0 do
            System.Threading.Thread.Sleep (100)
        printfn "current state is %A" this.State
        match this.State with
            | AccountState.Overdrawn -> ()
            | AccountState.Silver -> this.Deposit(balance * 0.01m)
            | AccountState.Gold -> this.Deposit(balance * 0.02m)
    member this.ShowBalance() =
        while bank.CurrentQueueLength > 0 do
            System.Threading.Thread.Sleep (100)
        printfn "current balance is %A" balance

let account = Account()
account.Deposit(1000.m<USD>)
account.Deposit(10000.m<USD>)
account.PayInterest()
account.ShowBalance()

Execution result in FSI

current state is Gold
current balance is 11220.00M

// define the sequence builder class
type SimpleSequence() = class
    member this.For(source:seq<'a>, f:'a -> seq<'b>) =
        seq { for n in source do yield! f n }
    member this.Yield(n) = seq { yield n }
end

let mySeq = SimpleSequence()
let r = mySeq { for i in 1..10 do yield i * i }

Translation result

let b = mySeq
b.For ( [1..10] , fun i -> b.Yield(i * i))

type SimpleSequence2() =
    member this.For(source:seq<'a>, f:'a -> seq<'b>) =
        seq { for n in source do yield! f n }
    member this.Yield(n) = seq { yield n }
    [<CustomOperation("where")>]
    member this.Where(source:seq<'a>, [<ProjectionParameter>]f:'a -> bool) =
        source |> Seq.filter f

let mySeq2 = SimpleSequence2()
let r2 = mySeq2 {
            for i in 1..10 do
            where (i > 3)
        }

Translation result

let b2 = mySeq2
b2.Where ( b.For([1..10] , fun i -> b.Yield(i)), fun i-> i > 3)

let r3 = mySeq2 {
            for i in 1..10 do
            let j = i + 3
            where (i > 5 && j < 10)
            }

Translation result

let b3 = mySeq2
b3.Where(b.For([1..10], fun i ->
                            let j = i + 3
                            b.Yield(i, j)),
         fun (i, j) -> i > 5 && j < 10)

type SimpleSequence3() =
    member this.For(source:seq<'a>, f:'a -> seq<'b>) =
        seq { for n in source do yield! f n }
    member this.Yield(n) = seq { yield n }
    [<CustomOperation("where", MaintainsVariableSpace=true)>]
    member this.Where(source:seq<'a>, [<ProjectionParameter>]f:'a -> bool) =
        source |> Seq.filter f

let mySeq3 = SimpleSequence3()
let r4 = mySeq3 {
            for i in 1..10 do
            let j = i + 3
            where (i > 5)
            where (j < 10)
            }

Translation result

let b4 = mySeq3
b4.Where(
    b4.Where(
    b4.For([1..10], fun i ->
                        let j = i + 3
                        b4.Yield(i, j)),
       fun (i, j) -> i > 5),
    fun (i, j) -> j < 10)

type SimpleSequence4() =
    member this.For(source:seq<'a>, f:'a -> seq<'b>) =
        seq { for n in source do yield! f n }
    member this.Yield(n) = seq { yield n }
    [<CustomOperation("where", AllowIntoPattern=true)>]
    member this.Where(source:seq<'a>, [<ProjectionParameter>]f:'a -> bool) =
        source |> Seq.filter f

let mySeq4 = SimpleSequence4()
let r5 = mySeq4 {
            for i in 1..10 do
            where (i > 5) into j
            where (j < 10)
            }

Translation result

let b5 = mySeq4
b5.Where(
    b5.For(
        b5.Where(
            b5.For([1..10], fun i-> b5.Yield(i)),
            fun i -> i > 5),
        fun j -> b5.Yield(j)),
fun j -> j < 10)

type SimpleSequence5() =
    member this.For(source:seq<'a>, f:'a -> seq<'b>) =
        seq { for n in source do yield! f n }
    member this.Return(n) = seq { yield n }
    [<CustomOperation("where",AllowIntoPattern=true,MaintainsVariableSpaceUsingBind=true)>]
    member this.Where(source:seq<'a>, [<ProjectionParameter>]f:'a -> bool) =
        source |> Seq.filter f
    member this.Bind(value, cont) = cont value


let mySeq5 = SimpleSequence5()

let r6 = mySeq5 {
            for i in 1..10 do
            where (i > 5 && i + 3 < 10) into j
            return j
         }

Translation result

let b6 = mySeq5

b6.Bind(
    b6.Where(
        b6.For([1..10], fun i -> b6.Return(i)),
                fun i -> i > 5 && i + 3 < 10),
            fun j -> b6.Return(j))

type SimpleSequenceBuilder() =
    member __.For (source : seq<'a>, body : 'a -> seq<'b>) =
           seq { for v in source do yield! body v }
    member __.Yield (item:'a) : seq<'a> = seq { yield item }

    [<CustomOperation("merge", IsLikeJoin = true, JoinConditionWord = "whenever")>]
    member __.Merge (src1:seq<'a>, src2:seq<'a>, ks1, ks2, ret) =
              seq { for a in src1 do
                    for b in src2 do
                    if ks1 a = ks2 b then yield((ret a ) b)
              }

let myseq = SimpleSequenceBuilder()

myseq {
    for i in 1 .. 10 do
    merge j in [5 .. 15] whenever (i = j)
    yield j
    }

let b = myseq

b.For(
   b.Merge([1..10], [5..15],
            (fun i -> i), (fun j -> j),
            (fun i -> fun j -> (i, j))),
   fun j -> b.Yield (j))

type Account<[<Measure>]'u>() =
    member val Balance = 0.0<_> with get, set
    member val PendingAmount = 0.0<_> with get, set

type Bank<[<Measure>]'u>(account:Account<'u>) =
    member this.Yield (()) =
        account

    [<CustomOperation("deposit")>]
    member this.Deposit (account:Account<'u>, v:float<'u>) : Account<'u> =
        account.PendingAmount <- account.PendingAmount + v
        account

    [<CustomOperation("withdraw")>]
    member this.Withdraw (account:Account<'u>, v:float<'u>) : Account<'u> =
        account.PendingAmount <- account.PendingAmount - v
        account

    member this.Run (account:Account<'u>) =
        fun () ->
            let finalBalance = account.Balance + account.PendingAmount
            if finalBalance > 0.<_> then
                account.Balance <- finalBalance
                account
            else
                printfn "not enough found"
                account

[<Measure>] type USD
let account = Account<USD>()
let bank = Bank<USD>(account)

let transaction =
    bank {
        deposit 100.<USD>
        withdraw 50.<USD>
    }

printfn "balance after one transaction = %A" (transaction().Balance)

 // define attribute with a property
type MyAttribute() =
    inherit System.Attribute()
    member val MyAttributeProperty = System.String.Empty with get, set

// define an attribute
type MyAttribute() =
    inherit System.Attribute()

// define an attribute
type MyAttribute2() =
    inherit System.Attribute()
// define a class with one attribute
[<MyAttribute>]
type MyClassWithOneAttribute() = class

    end

// define a class with two attributes applied separately
[<MyAttribute>]
[<MyAttribute2>]
type MyClassWithTwoAttributes() = class

    end

// define a class with two attributes applied as a group
[<MyAttribute; MyAttribute2>]
type MyClassWithGroupedAttribute() = class

    end

// apply an attribute to a method, property, and field
type MyClass3() =
    [<MyAttribute>]
    let mutable MyVariable = 0

    [<MyAttribute>]
    member this.MyMethod([<MyAttribute2; MyAttribute>] x0, [<MyAttribute>] x1) = ()

    member this.MyProperty
        with [<MyAttribute2>] get() = MyVariable
        and set(v) = MyVariable <- v

    [<MyAttribute>]
    member val MyProperty2 = 0 with get, set
// apply attribute to mutual reference class
type MyClass4() =
    let a:MyClass5 = MyClass5()
and [<MyAttribute>] MyClass5() = class

    end

// define an attribute
type MyAttribute() =
    inherit System.Attribute()

[<MyAttribute>]
let myValue = 0

[<MyAttribute>]
let myFunction x = x + 1

// the functionality from the following two statements are the same
let [<MyAttribute>] a, b = 1, 2

[<MyAttribute>]
let c, d = 1, 2

// apply an attribute to a function
let rec [<MyAttribute>] f() = g()

// apply an attribute to mutual reference functions
and [<MyAttribute>] g() = printfn "hello"

//apply an attribute to a record
[<MyAttribute>]
type Point = {
    [<MyAttribute>] x : float;
    [<MyAttribute>] y: float;
    z: float; }

// apply an attribute to a DU
[<MyAttribute>]
type DU =
| [<MyAttribute>] Case1 of float
| Case2 of double
| [<MyAttribute>] Case3 of double

// apply an attribute to a unit of measure
[<Measure; MyAttribute>] type km

// apply an attribute to an enumeration
[<MyAttribute>]
type Color =
   | [<MyAttribute>] Red = 0
   | Green = 1
   | [<MyAttribute>] Blue = 2

// apply an attribute to an exception type
[<MyAttribute>]
exception MyError of string

// apply an attribute to a tuple parameter
let f3 ([<MyAttribute>] a, [<MyAttribute>] b) = a + b
let f4 ([<MyAttribute>] a, [<MyAttribute>] b) c = a + b + c

[<MyAttribute>]
module MyModule =
    let myTest = 0

// apply an attribute to a primary constructor
type MyClass2[<MyAttribute>]() = class

    end

// apply an attribute to the parameter of a constructor
type MyClass([<MyAttribute>] xValue:double, yValue:double)=

    // define a static field named count
    [<MyAttribute>]
    static let mutable count = 0

    //additional constructor
    [<MyAttribute>]
    new() = MyClass(0., 0.)

Some F# structures do not accept attributes. The pattern matching expression let ([<MyAttribute>] myValue2, myValue3) segment in the following example does not support attributes. Also, attributes cannot be applied to the exception parameters in an F# exception definition. You can use an exception class definition to solve this problem. Also, curried functions do not accept attributes on parameters. The auto-implemented property’s getter and setter functions cannot have attributes. If the attribute is needed, you have to use the old syntax.

// pattern does not allow attribute
let ([<MyAttribute>] myValue2, myValue3) = (2, 3)

// attribute cannot be applied to exception parameter
exception MyError2 of [<MyAttribute>] string

//apply attribute to curried function
let f2 [<MyAttribute>]a [<MyAttribute>]b = a + 1

//apply attribute to auto-implemented property's getter or setter function
type MyClass() =
    member val MyProperty = 0 with [<MyAttribute >] get, set

Typeof and typedefof code

typeof<System.Collections.Generic.IEnumerable<_>>

typedefof<System.Collections.Generic.IEnumerable<_>>

Execution result

val it : System.Type =
  System.Collections.Generic.IEnumerable'1[System.Object]

val it : System.Type =
  System.Collections.Generic.IEnumerable'1[T]

// define student class
type Student(nameIn : string, idIn : int) =
    let mutable name = nameIn
    let mutable id = idIn

    do printfn "Created a student object"
    member this.Name with get() = name and set v = name <- v
    member this.ID with get() = id and set v = id <- v
    member public this.SetStudentInfo(name, id) =
        this.Name <- name
        this.ID <- id

module TestModule =

    let student = Student("John", 16)
    let studentType = typeof<Student>

    //use reflection to invoke SetStudentInfo method
    let result = studentType.GetMethod("SetStudentInfo").Invoke(student, [| "Brent"; 18 |]
)

    printfn "new student info: name = %s, id = %d" student.Name student.ID

Execution result

Created a student object
new student info: name = Brent, id = 18