F# for Fun and Profit

https://github.com/swlaschin/fsharpforfunandprofit.gitbook
Admin
F# for Fun and Profit is an educational resource introducing F# as a functional/hybrid programming...
Tokens:868,992
Snippets:6,443
Trust Score:8.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup test data for API

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-6.md

Configures the API client with test purchases and product information, then executes the setup action.

```fsharp
let setupTestData (api:ApiClient) =
    //setup purchases
    api.Set (CustId "C1") [ProductId "P1"; ProductId "P2"] |> ignore
    api.Set (CustId "C2") [ProductId "PX"; ProductId "P2"] |> ignore

    //setup product info
    api.Set (ProductId "P1") {ProductName="P1-Name"} |> ignore
    api.Set (ProductId "P2") {ProductName="P2-Name"} |> ignore
    // P3 missing

// setupTestData is an api-consuming function
// so it can be put in an ApiAction 
// and then that apiAction can be executed
let setupAction = ApiAction setupTestData
ApiAction.execute setupAction
```

--------------------------------

### Output for good sites parallel download

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-5.md

Example output showing successful parallel downloads of all four good sites, with all starting before the first finishes. Demonstrates the average time per run.

```text
[google.co.uk] Started ...
[bbc.co.uk] Started ...
[fsharp.org] Started ...
[microsoft.com] Started ...
[bbc.co.uk] ... finished
[fsharp.org] ... finished
[google.com] ... finished
[microsoft.com] ... finished

SUCCESS: [bbc.co.uk] Content size is 108983
largestPageSizeA_Good: Average time per run:   533ms 

```

--------------------------------

### Define and run a browser test with Canopy

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work-3.md

This example demonstrates how to start a browser, define a test case with assertions and interactions, and execute the test suite.

```fsharp
//start an instance of the firefox browser
start firefox

//this is how you define a test
"taking canopy for a spin" &&& fun _ ->
    //go to url
    url "http://lefthandedgoat.github.io/canopy/testpages/"

    //assert that the element with an id of 'welcome' has
    //the text 'Welcome'
    "#welcome" == "Welcome"

    //assert that the element with an id of 'firstName' has the value 'John'
    "#firstName" == "John"

    //change the value of element with
    //an id of 'firstName' to 'Something Else'
    "#firstName" << "Something Else"

    //verify another element's value, click a button,
    //verify the element is updated
    "#button_clicked" == "button not clicked"
    click "#button"
    "#button_clicked" == "button clicked"

//run all tests
run()
```

--------------------------------

### Constructor function example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/designing-with-types-more-semantic-types.md

Example of creating a constructor function using the create helper.

```fsharp
let string100 = create singleLineTrimmed (lengthValidator 100) String100
```

--------------------------------

### List ordering and permutation examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/list-module-functions.md

Examples demonstrating the use of List.rev, List.sort, List.sortDescending, List.sortBy, List.sortWith, and List.permute.

```fsharp
[1..5] |> List.rev
// [5; 4; 3; 2; 1]

[2;4;1;3;5] |> List.sort
// [1; 2; 3; 4; 5]

[2;4;1;3;5] |> List.sortDescending
// [5; 4; 3; 2; 1]

[ ("b","2"); ("a","3"); ("c","1") ]  |> List.sortBy fst
// [("a", "3"); ("b", "2"); ("c", "1")]

[ ("b","2"); ("a","3"); ("c","1") ]  |> List.sortBy snd
// [("c", "1"); ("b", "2"); ("a", "3")]

// example of a comparer
let tupleComparer tuple1 tuple2  =
    if tuple1 < tuple2 then 
        -1 
    elif tuple1 > tuple2 then 
        1 
    else
        0

[ ("b","2"); ("a","3"); ("c","1") ]  |> List.sortWith tupleComparer
// [("a", "3"); ("b", "2"); ("c", "1")]

[1..10] |> List.permute (fun i -> (i + 3) % 10)
// [8; 9; 10; 1; 2; 3; 4; 5; 6; 7]

[1..10] |> List.permute (fun i -> 9 - i)
// [10; 9; 8; 7; 6; 5; 4; 3; 2; 1]
```

--------------------------------

### Complete property example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/classes.md

A comprehensive example demonstrating immutable, mutable, private-set, and automatic properties.

```fsharp
type PropertyExample(seed) = 
    // private mutable value
    let mutable myProp = seed

    // private function
    let square x = x * x

    // immutable property 
    // using a constructor parameter
    member this.Seed = seed

    // immutable property 
    // using a private function
    member this.SeedSquared = square seed

    // mutable property
    // changing a private mutable value
    member this.MyProp 
        with get() = myProp 
        and set(value) =  myProp <- value

    // mutable property with private set
    member this.MyProp2 
        with get() = myProp 
        and private set(value) =  myProp <- value

    // automatic immutable property (in VS2012)
    member val ReadOnlyAuto = 1

    // automatic mutable property (in VS2012)
    member val ReadWriteAuto = 1 with get,set

// test 
let pe = new PropertyExample(42)
printfn "%i" <| pe.Seed
printfn "%i" <| pe.SeedSquared
printfn "%i" <| pe.MyProp
printfn "%i" <| pe.MyProp2

// try calling set
pe.MyProp <- 43    // Ok
printfn "%i" <| pe.MyProp

// try calling private set
pe.MyProp2 <- 43   // Error
```

--------------------------------

### Execute complex stack examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/stack-based-calculator.md

Examples of using the helper functions to perform calculations on the stack.

```fsharp
START
    |> ONE |> TWO |> SHOW

START
    |> ONE |> TWO |> ADD |> SHOW 
    |> THREE |> ADD |> SHOW 

START
    |> THREE |> DUP |> DUP |> MUL |> MUL // 27

START
    |> ONE |> TWO |> ADD |> SHOW  // 3
    |> THREE |> MUL |> SHOW       // 9
    |> TWO |> SWAP |> DIV |> SHOW // 9 div 2 = 4.5
```

--------------------------------

### Example with ReturnFrom issue

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-builder-part5.md

Shows an example that fails because ReturnFrom needs to be updated to handle the new Maybe type.

```fsharp
let m2 = maybe { 
    printfn "Part 1: about to return None"
    return! None
    printfn "Part 2: after None, keep going"
    } 
```

--------------------------------

### Sequential processing example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-builder-part2.md

Example usage of the TraceBuilder with sequential processing.

```fsharp
trace { 
    if true then printfn "hello......."
    if false then printfn ".......world"
    return 1
    } |> printfn "Result for sequential combine: %A" 
```

--------------------------------

### Example product instances

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/recursive-types-and-folds-1b.md

Instances of Bought and Made products demonstrating the recursive structure.

```fsharp
let label = 
    Bought {name="label"; weight=1; vendor=Some "ACME"}
let bottle = 
    Bought {name="bottle"; weight=2; vendor=Some "ACME"}
let formulation = 
    Bought {name="formulation"; weight=3; vendor=None}

let shampoo = 
    Made {name="shampoo"; weight=10; components=
    [
    {qty=1; product=formulation}
    {qty=1; product=bottle}
    {qty=2; product=label}
    ]}

let twoPack = 
    Made {name="twoPack"; weight=5; components=
    [
    {qty=2; product=shampoo}
    ]}
```

--------------------------------

### Start game function

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/enterprise-tic-tac-toe.md

Function to transition the UI state to Playing.

```fsharp
let startGame()= 
    uiState <- Playing api.newGame
    // create cell grid from gameState 
```

--------------------------------

### Running the logging pipeInto example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-continuations.md

Executes the logging-enabled pipeInto workflow.

```fsharp
pipeInto (42, fun x ->
pipeInto (43, fun y -> 
pipeInto (x + y, fun z -> 
z
)))
```

--------------------------------

### Create example Gift values

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/recursive-types-and-folds-2.md

Provides sample values for Book, Chocolate, and Gift used in the post's examples.

```fsharp
// A Book
let wolfHall = {title="Wolf Hall"; price=20m}
// A Chocolate
let yummyChoc = {chocType=SeventyPercent; price=5m}
// A Gift
let birthdayPresent = WithACard (Wrapped (Book wolfHall, HappyBirthday), "Happy Birthday")
// A Gift
let christmasPresent = Wrapped (Boxed (Chocolate yummyChoc), HappyHolidays)
```

--------------------------------

### Partial application of List library functions

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/partial-application.md

Examples showing how the functions from the previous example can be partially applied.

```fsharp
let eachAdd1 = List.map (fun i -> i+1) 
eachAdd1 [0;1;2;3]

let excludeOneOrLess = List.filter (fun i -> i>1) 
excludeOneOrLess [0;1;2;3]

let sortDesc = List.sortBy (fun i -> -i) 
sortDesc [0;1;2;3]
```

--------------------------------

### Imperative order total example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/monoids-part2.md

Complete imperative example with OrderLine type, calculateOrderTotal, sample order lines, and printing the total.

```fsharp
module OrdersUsingImperative = 

    type OrderLine = {
        ProductCode: string
        Qty: int
        Total: float
        }
 
    let calculateOrderTotal lines = 
        let mutable total = 0.0
        for line in lines do
            total <- total + line.Total
        total

    let orderLines = [
        {ProductCode="AAA"; Qty=2; Total=19.98}
        {ProductCode="BBB"; Qty=1; Total=1.99}
        {ProductCode="CCC"; Qty=3; Total=3.99}
        ]
            
    orderLines 
    |> calculateOrderTotal 
    |> printfn "Total is %g"
```

--------------------------------

### Collection Conversion Usage Examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/list-module-functions.md

Examples demonstrating the conversion of a list to an array using List.toArray and an array to a list using Array.ofList.

```fsharp
[1..5] |> List.toArray      // [|1; 2; 3; 4; 5|]
[1..5] |> Array.ofList      // [|1; 2; 3; 4; 5|]
// etc
```

--------------------------------

### Curried addTwoParameters example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/currying.md

Another example showing the normal and explicitly curried versions of a two-parameter addition function, plus step-by-step and normal usage.

```fsharp
//normal version
let addTwoParameters x y = 
   x + y

//explicitly curried version
let addTwoParameters x  =      // only one parameter!
   let subFunction y = 
      x + y                    // new function with one param
   subFunction                 // return the subfunction

// now use it step by step 
let x = 6
let y = 99
let intermediateFn = addTwoParameters x  // return fn with 
                                         // x "baked in"
let result  = intermediateFn y 

// normal version
let result  = addTwoParameters x y
```

--------------------------------

### Define good and bad site lists in F#

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-5.md

Provides lists of URLs, 'goodSites' with valid sites and 'badSites' with invalid URLs, used in the download examples. Includes examples like google.com and veryverybad.example.com.

```F#
let goodSites = [
    "http://google.com"
    "http://bbc.co.uk"
    "http://fsharp.org"
    "http://microsoft.com"
    ]

let badSites = [
    "http://example.com/nopage"
    "http://bad.example.com"
    "http://verybad.example.com"
    "http://veryverybad.example.com"
    ]

```

--------------------------------

### The 'fun' keyword does not start a new offside line

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/fsharp-syntax.md

When a 'fun' keyword starts an expression, it does not start a new offside line. The real line starts after the 'fun' expression, as shown in the example.

```fsharp
//character columns
//34567890123456789
let f = fun x ->  // "fun" should define a new line at col 9
   let y = 1      // but doesn't. The real line starts here.
   x + y          
```

--------------------------------

### Infix operators starting a line don't need strict alignment

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/fsharp-syntax.md

When an infix operator starts a line, that line does not have to be strictly aligned. The example shows '+', '*', and '-' starting lines without strict alignment.

```fsharp
let x =  1   // defines a new line at col 10
        + 2   // infix operators that start a line don't count
             * 3  // starts with "*" so doesn't need to align
         - 4  // starts with "-" so doesn't need to align
```

--------------------------------

### Create sample file system items

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/recursive-types-and-folds-1b.md

Creates sample File and Directory values to be used with the catamorphism. The example builds a small hierarchy with readme, config, build files and src, bin directories under a root directory.

```fsharp
let readme = File {name="readme.txt"; fileSize=1}
let config = File {name="config.xml"; fileSize=2}
let build  = File {name="build.bat"; fileSize=3}
let src = Directory {name="src"; dirSize=10; subitems=[readme; config; build]}
let bin = Directory {name="bin"; dirSize=10; subitems=[]}
let root = Directory {name="root"; dirSize=5; subitems=[src; bin]}
```

--------------------------------

### Usage of Option.traverseResultA with valid input

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-4.md

Example of wrapping a string in an Option and using traverseResultA with parseInt to get a Result containing an Option.

```fsharp
// pass in an string wrapped in an Option
let good = Some "1" |> Option.traverseResultA parseInt
// get back a Result containing an Option
// Success (Some 1)
```

--------------------------------

### Directory listing output

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/recursive-types-and-folds-3b.md

Example output format for the directory listing.

```text
  8315  10/08/2015 23:37:41  Fold.fsx
  3680  11/08/2015 23:59:01  FoldAndRecursiveTypes.fsproj
  1010  11/08/2015 01:19:07  FoldAndRecursiveTypes.sln
  1107  11/08/2015 23:59:01  HtmlDom.fsx
    79  11/08/2015 01:21:54  LinkedList.fsx
```

--------------------------------

### Simple partial application examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/partial-application.md

Demonstrates creating specialized functions like adders, testers, and printers by partially applying operators and functions.

```fsharp
// create an "adder" by partial application of add
let add42 = (+) 42    // partial application
add42 1
add42 3

// create a new list by applying the add42 function 
// to each element
[1;2;3] |> List.map add42 

// create a "tester" by partial application of "less than"
let twoIsLessThan = (<) 2   // partial application
twoIsLessThan 1
twoIsLessThan 3

// filter each element with the twoIsLessThan function
[1;2;3] |> List.filter twoIsLessThan 

// create a "printer" by partial application of printfn
let printer = printfn "printing param=%i" 

// loop over each element and call the printer function
[1;2;3] |> List.iter printer   
```

--------------------------------

### F# IShape Interface Definition

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/fsharp-decompiled.md

Defines an F# interface named IShape with abstract members Name and Draw. This is the starting point for the class hierarchy example.

```fsharp
/// Interface
type IShape =
    abstract Name : string
    abstract Draw : unit -> unit
```

--------------------------------

### Setup test files

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/correctness-exhaustive-pattern-matching.md

Helper function to write text to a file and initialize test filenames.

```fsharp
/// write some text to a file
let writeSomeText filePath someText = 
    use writer = new System.IO.StreamWriter(filePath:string)
    writer.WriteLine(someText:string)
    writer.Close()

let goodFileName = "good.txt"
let badFileName = "bad.txt"

writeSomeText goodFileName "hello"
```

--------------------------------

### Continuation chain example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-builder-part6.md

Shows how a series of expressions is converted into a chain of continuations.

```fsharp
Bind(1,fun x -> 
   Bind(2,fun y -> 
     Bind(x + y,fun z -> 
        Return(z)  // or Yield
```

--------------------------------

### Create Implementations with Partial Application

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/13-ways-of-looking-at-a-turtle.md

Demonstrates creating normal and half-size turtle implementations using partial application to bake in dependencies.

```fsharp
let log = printfn "%s"
let move = Turtle.move log 
let turn = Turtle.turn log 
let penUp = Turtle.penUp log
let penDown = Turtle.penDown log
let setColor = Turtle.setColor log 

let normalSize() = 
    let turtleFn = function
        | Move dist -> move dist 
        | Turn angle -> turn angle
        | PenUp -> penUp 
        | PenDown -> penDown 
        | SetColor color -> setColor color

    // partially apply the function to the API
    let api = TurtleApi() 
    api.Exec turtleFn 
    // the return value is a function: 
    //     string -> Result<unit,ErrorMessage> 

let halfSize() = 
    let turtleFn = function
        | Move dist -> move (dist/2.0)  
        | Turn angle -> turn angle
        | PenUp -> penUp 
        | PenDown -> penDown 
        | SetColor color -> setColor color

    // partially apply the function to the API
    let api = TurtleApi() 
    api.Exec turtleFn 
    // the return value is a function: 
    //     string -> Result<unit,ErrorMessage> 
```

--------------------------------

### F# shrinking example with Arb.shrink

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/property-based-testing.md

Shows how shrinking works by evaluating the property with the last failing inputs (46,-4,50) and then using Arb.shrink 46 to get a list of possible shrinks.

```fsharp
// The last set of inputs (46,-4,50) was false, so shrinking started
associativeProperty 46 -4 50  // false, so shrink

// list of possible shrinks starting at 46
Arb.shrink 46 |> Seq.toList 
// result [0; 23; 35; 41; 44; 45]
```

--------------------------------

### Demonstration of Using in action

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-builder-part6.md

An example showing how to use the Using method with a wrapped disposable resource.

```fsharp
let makeResource name =
    Some { 
    new System.IDisposable with
    member this.Dispose() = printfn "Disposing %s" name
    }

trace { 
    use! x = makeResource "hello"
    printfn "Disposable in use"
    return 1
    } |> printfn "Result: %A"
```

--------------------------------

### Run sleepWorkflowMs in series with Async.RunSynchronously

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/concurrency-async-and-parallel.md

Combines two sleep workflows in series using let! bindings, so the second starts only after the first finishes. The #time directive toggles the timer and only works in the interactive window; the example must be sent there to run correctly.

```fsharp
let workflowInSeries = async {
    let! sleep1 = sleepWorkflowMs 1000
    printfn "Finished one" 
    let! sleep2 = sleepWorkflowMs 2000
    printfn "Finished two" 
    }

#time
Async.RunSynchronously workflowInSeries 
#time
```

--------------------------------

### Instantiate a class using the new keyword

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/classes.md

Demonstrates creating a class instance using the 'new' keyword, similar to C# syntax.

```fsharp
type MyClass(intParam:int, strParam:string) = 
    member this.Two = 2
    member this.Square x = x * x

let myInstance = new MyClass(1,"hello")
```

--------------------------------

### Install NuGet command line with Chocolatey

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work.md

Run this command after installing Chocolatey to install the NuGet command line tool.

```bash
cinst nuget.commandline
```

--------------------------------

### Create and use adder functions

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/how-types-work-with-functions.md

Demonstrates creating specific adder functions and using them.

```fsharp
let add1 = adderGenerator 1
let add2 = adderGenerator 2
```

```fsharp
val add1 : (int -> int)
val add2 : (int -> int)
```

```fsharp
add1 5    // val it : int = 6
add2 5    // val it : int = 7
```

--------------------------------

### Foq mocking in F#

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work-3.md

Equivalent examples of setting up mocks for methods, argument matching, and properties using the Foq library in F#.

```fsharp
// Foq Method
let mock = 
    Mock<IFoo>()
        .Setup(fun foo -> <@ foo.DoSomething("ping") @>).Returns(true)
        .Create()

// Foq Matching Arguments
mock.Setup(fun foo -> <@ foo.DoSomething(any()) @>).Returns(true)

// Foq Property
mock.Setup(fun foo -> <@ foo.Name @>).Returns("bar")
```

--------------------------------

### Test readAllChars with examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/understanding-parser-combinators-3.md

Example usage of readAllChars with different input strings.

```fsharp
fromStr "" |> readAllChars       // []
fromStr "a" |> readAllChars      // ['a'; '\n']
fromStr "ab" |> readAllChars     // ['a'; 'b'; '\n']
fromStr "a\nb" |> readAllChars   // ['a'; '\n'; 'b'; '\n']
```

--------------------------------

### Bootstrap calculator services and UI

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/calculator-implementation.md

Example of the main application entry point where services are created, injected into the factory method, and passed to the UI.

```fsharp
// create the services
let services = CalculatorServices.createServices()

// inject the services into the "factory" method
let calculate = CalculatorImplementation.createCalculate services

// the returned "calculate" function is of type Calculate 
// and can be passed into the UI, for example

// create the UI and run it
let form = new CalculatorUI.CalculatorForm(calculate)
form.Show()
```

--------------------------------

### HTTP Response Example 3

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work.md

An example of an HTTP response returning a JSON string.

```text
StatusCode: 200, ReasonPhrase: 'OK', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
{
  Date: Fri, 18 Apr 2014 22:29:04 GMT
  Server: Microsoft-HTTPAPI/2.0
  Content-Length: 10
  Content-Type: application/json; charset=utf-8
}
"id is 42"
```

--------------------------------

### HTTP Response Example 2

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work.md

An example of an HTTP response returning a JSON array.

```text
StatusCode: 200, ReasonPhrase: 'OK', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
{
  Date: Fri, 18 Apr 2014 22:29:04 GMT
  Server: Microsoft-HTTPAPI/2.0
  Content-Length: 29
  Content-Type: application/json; charset=utf-8
}
[
  "value1",
  "value2"
]
```

--------------------------------

### HTTP Response Example 1

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work.md

An example of an HTTP response returning a JSON object.

```text
StatusCode: 200, ReasonPhrase: 'OK', Version: 1.1, Content: System.Net.Http.StreamContent, Headers:
{
  Date: Fri, 18 Apr 2014 22:29:04 GMT
  Server: Microsoft-HTTPAPI/2.0
  Content-Length: 24
  Content-Type: application/json; charset=utf-8
}
{
  "text": "Hello!"
}
```

--------------------------------

### Result of for loop example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/computation-expressions-builder-part2.md

The output produced by the nested for loop computation expression example.

```text
["red"; "red hat"; "-"; "red tie"; "-"; "blue"; "blue hat"; "-"; "blue tie"; "-"]
```

--------------------------------

### List Module Partitioning and Grouping Usage Examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/list-module-functions.md

Demonstrates standard usage of various List module functions for splitting and grouping collections.

```fsharp
[1..10] |> List.chunkBySize 3
// [[1; 2; 3]; [4; 5; 6]; [7; 8; 9]; [10]]  
// note that the last chunk has one element

[1..10] |> List.splitInto 3
// [[1; 2; 3; 4]; [5; 6; 7]; [8; 9; 10]]
// note that the first chunk has four elements

['a'..'i'] |> List.splitAt 3
// (['a'; 'b'; 'c'], ['d'; 'e'; 'f'; 'g'; 'h'; 'i'])

['a'..'e'] |> List.pairwise
// [('a', 'b'); ('b', 'c'); ('c', 'd'); ('d', 'e')]

['a'..'e'] |> List.windowed 3
// [['a'; 'b'; 'c']; ['b'; 'c'; 'd']; ['c'; 'd'; 'e']]

let isEven i = (i%2 = 0)
[1..10] |> List.partition isEven 
// ([2; 4; 6; 8; 10], [1; 3; 5; 7; 9])

let firstLetter (str:string) = str.[0]
["apple"; "alice"; "bob"; "carrot"] |> List.groupBy firstLetter 
// [('a', ["apple"; "alice"]); ('b', ["bob"]); ('c', ["carrot"])]
```

--------------------------------

### Apply applyM step-by-step to build bodyM

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/monadster-2.md

Shows the step-by-step application of applyM to a six-parameter function wrapped in M, progressively reducing the parameter count until the final M<LiveBody> is obtained. Each step applies one M-wrapped parameter, and the comments explain the intermediate states.

```fsharp
// move createBody to M-world -- a six parameter function wrapped in an M
let fSixParamM = returnM createBody           

// apply first M-param to get a five parameter function wrapped in an M
let fFiveParamM = applyM fSixParamM leftLegM   

// apply second M-param to get a four parameter function wrapped in an M
let fFourParamM = applyM fFiveParamM rightLegM 

// etc
let fThreeParamM = applyM fFourParamM leftArmM
let fTwoParamM = applyM fThreeParamM rightArmM
let fOneParamM = applyM fTwoParamM headM 

// after last application, the result is a M<LiveBody>
let bodyM = applyM fOneParamM beatingHeartM   
```

--------------------------------

### Start the game with API

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/enterprise-tic-tac-toe.md

Initializes the game loop with the provided API and a new game action.

```fsharp
/// start the game with the given API
    let startGame api =
        let userAction = ContinuePlay api.newGame
        gameLoop api userAction 
```

--------------------------------

### Custom operator starting with *

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/defining-functions.md

A space is required after the opening parenthesis when the operator starts with * to avoid comment syntax.

```fsharp
let ( *+* ) x y = x + y + 1
```

--------------------------------

### Moq mocking in C#

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work-3.md

Examples of setting up mocks for methods, argument matching, and properties using the Moq library in C#.

```csharp
// Moq Method
var mock = new Mock<IFoo>();
mock.Setup(foo => foo.DoSomething("ping")).Returns(true);
var instance = mock.Object;

// Moq Matching Arguments:
mock.Setup(foo => foo.DoSomething(It.IsAny<string>())).Returns(true);

// Moq Property
mock.Setup(foo => foo.Name ).Returns("bar");
```

--------------------------------

### Example game output

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/enterprise-tic-tac-toe.md

A sample console session showing the board state, available moves, and game conclusion.

```text
|-|X|-|
|X|-|-|
|O|-|-|

Player O to move
0) PlayerOPos (Left, Top)
1) PlayerOPos (HCenter, VCenter)
2) PlayerOPos (HCenter, Bottom)
3) PlayerOPos (Right, Top)
4) PlayerOPos (Right, VCenter)
5) PlayerOPos (Right, Bottom)
Enter an int corresponding to a displayed move or q to quit:
1

------------------------------

|-|X|-|
|X|O|-|
|O|-|-|

Player X to move
0) PlayerXPos (Left, Top)
1) PlayerXPos (HCenter, Bottom)
2) PlayerXPos (Right, Top)
3) PlayerXPos (Right, VCenter)
4) PlayerXPos (Right, Bottom)
Enter an int corresponding to a displayed move or q to quit:
1

------------------------------

|-|X|-|
|X|O|-|
|O|X|-|

Player O to move
0) PlayerOPos (Left, Top)
1) PlayerOPos (Right, Top)
2) PlayerOPos (Right, VCenter)
3) PlayerOPos (Right, Bottom)
Enter an int corresponding to a displayed move or q to quit:
1

------------------------------

|-|X|O|
|X|O|-|
|O|X|-|

GAME WON by PlayerO

Would you like to play again (y/n)?
```

--------------------------------

### Type abbreviation examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/type-abbreviations.md

Examples of various type abbreviations ranging from basic types to function signatures.

```fsharp
type RealNumber = float
type ComplexNumber = float * float
type ProductCode = string
type CustomerId = int
type AdditionFunction = int->int->int
type ComplexAdditionFunction = 
       ComplexNumber-> ComplexNumber -> ComplexNumber
```

--------------------------------

### Guard examples: comparing, properties, regex, and FizzBuzz

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/match-expression.md

A set of examples showing different uses of guards: comparing values, testing object properties, using regular expressions, and arbitrary conditionals (FizzBuzz). Each example includes test calls.

```fsharp
// --------------------------------
// comparing values in a when clause
let makeOrdered aTuple = 
    match aTuple with 
    // swap if x is bigger than y
    | (x,y) when x > y -> (y,x)
        
    // otherwise leave alone
    | _ -> aTuple

//test        
makeOrdered (1,2)        
makeOrdered (2,1)

// --------------------------------
// testing properties in a when clause        
let isAM aDate = 
    match aDate:System.DateTime with 
    | x when x.Hour <= 12-> 
        printfn "AM"
        
    // otherwise leave alone
    | _ -> 
        printfn "PM"

//test
isAM System.DateTime.Now

// --------------------------------
// pattern matching using regular expressions
open System.Text.RegularExpressions

let classifyString aString = 
    match aString with 
    | x when Regex.Match(x,@".+@.+").Success-> 
        printfn "%s is an email" aString
        
    // otherwise leave alone
    | _ -> 
        printfn "%s is something else" aString


//test
classifyString "alice@example.com"
classifyString "google.com"

// --------------------------------
// pattern matching using arbitrary conditionals
let fizzBuzz x = 
    match x with 
    | i when i % 15 = 0 -> 
        printfn "fizzbuzz" 
    | i when i % 3 = 0 -> 
        printfn "fizz" 
    | i when i % 5 = 0 -> 
        printfn "buzz" 
    | i  -> 
        printfn "%i" i

//test
[1..30] |> List.iter fizzBuzz
```

--------------------------------

### Create a Customer instance and access Address property

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/is-your-language-unreasonable.md

Demonstrates the instantiation of a Customer object and the subsequent access of its Address property, highlighting the potential for null reference issues.

```csharp
// create a customer
var cust = new Customer();

// what is the expected output?
Console.WriteLine(cust.Address.Country);
```

--------------------------------

### Implement Stack-based Hello World

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/monadster-3.md

Demonstrates using the state-aware push and pop operations to manipulate strings on the stack.

```fsharp
let helloWorldS = state {
    do! push "world"
    do! push "hello" 
    let! top1 = pop()
    let! top2 = pop()
    let combined = top1 + " " + top2 
    return combined 
    }

let helloWorld = getValue helloWorldS // "hello world"
```

--------------------------------

### F# DllImport attribute example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/let-use-do.md

F# equivalent of the DllImport example, showing the extern declaration with types before parameters.

```fsharp
open System.Runtime.InteropServices
open System.Text

[<DllImport("shlwapi", CharSet = CharSet.Ansi, EntryPoint = "PathCanonicalize", SetLastError = true)>]
extern bool PathCanonicalize(StringBuilder lpszDst, string lpszSrc)

let TestPathCanonicalize() = 
    let input = @"A:\name_1\.\name_2\..\name_3"
    let expected = @"A:\name_1\name_3"

    let builder = new StringBuilder(260)
    let success = PathCanonicalize(builder, input)
    let actual = builder.ToString()

    printfn "actual=%s success=%b" actual (expected = actual)

// test
TestPathCanonicalize() 
```

--------------------------------

### Load and open the ParserLibrary

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/understanding-parser-combinators-4.md

Initializes the environment by loading the parser library script and opening the required namespace.

```fsharp
#load "ParserLibrary.fsx"

open System
open ParserLibrary
```

--------------------------------

### Execute code during construction with do blocks

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/classes.md

Demonstrates using a 'do' block to execute code immediately upon class instantiation.

```fsharp
type DoExample(seed) = 
    let privateValue = seed + 1
    
    //extra code to be done at construction time
    do printfn "the privateValue is now %i" privateValue 
    
// test
new DoExample(42)
```

--------------------------------

### C# DllImport attribute example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/let-use-do.md

C# example of using DllImport to call an unmanaged function, including a test method.

```csharp
using System.Runtime.InteropServices;

[TestFixture]
public class TestDllImport
{
    [DllImport("shlwapi", CharSet = CharSet.Auto, EntryPoint = "PathCanonicalize", SetLastError = true)]
    private static extern bool PathCanonicalize(StringBuilder lpszDst, string lpszSrc);

    [Test]
    public void TestPathCanonicalize()
    {
        var input = @"A:\name_1\.\name_2\..\name_3";
        var expected = @"A:\name_1\name_3";

        var builder = new StringBuilder(260);
        PathCanonicalize(builder, input);
        var actual = builder.ToString();

        Assert.AreEqual(expected,actual);
    }
}
```

--------------------------------

### Asynchronous workflow examples with do! and let!

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/let-use-do.md

Demonstrates using do! to wait for an asynchronous sleep operation and let! to bind to the result of a child asynchronous workflow.

```fsharp
//This simple workflow just sleeps for 2 seconds.
open System
let sleepWorkflow  = async{
    printfn "Starting sleep workflow at %O" DateTime.Now.TimeOfDay
    
    // do! means to wait as well
    do! Async.Sleep 2000
    printfn "Finished sleep workflow at %O" DateTime.Now.TimeOfDay
    }

//test
Async.RunSynchronously sleepWorkflow  


// Workflows with other async workflows nested inside them. 
/// Within the braces, the nested workflows can be blocked on by using the let! or use! syntax.
let nestedWorkflow  = async{

    printfn "Starting parent"
    
    // let! means wait and then bind to the childWorkflow value
    let! childWorkflow = Async.StartChild sleepWorkflow

    // give the child a chance and then keep working
    do! Async.Sleep 100
    printfn "Doing something useful while waiting "

    // block on the child
    let! result = childWorkflow

    // done
    printfn "Finished parent" 
    }

// run the whole workflow
Async.RunSynchronously nestedWorkflow
```

--------------------------------

### Pointer type literal examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/cli-types.md

Examples of F# pointer/handle literals: nativeint with 'n' suffix and unativeint with 'un' suffix.

```fsharp
0xFFFFFFFFn
```

```fsharp
0xFFFFFFFFun
```

--------------------------------

### Create dead leg and M recipe

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/monadster.md

Initializes a dead leg and creates the M recipe for generating a live leg.

```fsharp
let deadLeftLeg = DeadLeftLeg "Boris"
let leftLegM = makeLiveLeftLegM deadLeftLeg
```

--------------------------------

### Define ADD using binary helper

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/stack-based-calculator.md

Demonstrates the evolution of the ADD function definition from using a lambda to using partial application.

```fsharp
let ADD aStack = binary (fun x y -> x + y) aStack
```

```fsharp
let ADD aStack = binary (+) aStack
```

```fsharp
let ADD = binary (+)
```

--------------------------------

### Examples of monadic functions

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/monadster-3.md

Examples of actual monadic functions used in the series, including makeLiveLeftLeg, makeLiveRightLowerArm, makeLiveHeart, makeBeatingHeart, and returnM.

```fsharp
val makeLiveLeftLeg : DeadLeftLeg -> M<LiveLeftLeg>
val makeLiveRightLowerArm : DeadRightLowerArm -> M<LiveRightLowerArm>
val makeLiveHeart : DeadHeart -> M<LiveHeart>
val makeBeatingHeart : LiveHeart -> M<BeatingHeart>
// and also
val returnM : 'a -> M<'a>
```

--------------------------------

### Typical micro-benchmark timing result

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/typesafe-performance-with-compiler-directives.md

Example output showing the time and garbage collection statistics for the wrapper type benchmark.

```text
Real: 00:00:00.296, CPU: 00:00:00.296, GC gen0: 6, gen1: 4, gen2: 0
```

--------------------------------

### Generated T-SQL Agent Script Example

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work-4.md

An example of the formatted T-SQL output generated by the F# script, suitable for DBA review.

```sql
USE [msdb]
GO

-- =====================================================
-- Script that deletes and recreates the SQL Agent job 'My SqlAgent Job'
-- 
-- The job steps are:
-- 1) An SSIS package
     -- {Continue on error=false} 
-- 2) Another SSIS package
     -- {Continue on error=false} 

-- =====================================================
```

--------------------------------

### Defining and Using Functions

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/fsharp-in-60-seconds.md

Demonstrates function definition, nested functions, piping, and lambda expressions.

```fsharp
// ======== Functions ========
// The "let" keyword also defines a named function.
let square x = x * x          // Note that no parens are used.
square 3                      // Now run the function. Again, no parens.

let add x y = x + y           // don't use add (x,y)! It means something
                              // completely different.
add 2 3                       // Now run the function.

// to define a multiline function, just use indents. No semicolons needed.
let evens list =
   let isEven x = x%2 = 0     // Define "isEven" as an inner ("nested") function
   List.filter isEven list    // List.filter is a library function
                              // with two parameters: a boolean function
                              // and a list to work on

evens oneToFive               // Now run the function

// You can use parens to clarify precedence. In this example,
// do "map" first, with two args, then do "sum" on the result.
// Without the parens, "List.map" would be passed as an arg to List.sum
let sumOfSquaresTo100 =
   List.sum ( List.map square [1..100] )

// You can pipe the output of one operation to the next using "|>"
// Here is the same sumOfSquares function written using pipes
let sumOfSquaresTo100piped =
   [1..100] |> List.map square |> List.sum  // "square" was defined earlier

// you can define lambdas (anonymous functions) using the "fun" keyword
let sumOfSquaresTo100withFun =
   [1..100] |> List.map (fun x->x*x) |> List.sum

// In F# returns are implicit -- no "return" needed. A function always
// returns the value of the last expression used.
```

--------------------------------

### F#: Partial application with fetchUrl2

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/fvsc-download.md

Builds a new function fetchUrl2 by baking in the callback, then tests it with individual URLs and a list of sites using List.map. This demonstrates F#'s partial application feature, which is not easily done in C#.

```fsharp
// build a function with the callback "baked in"
let fetchUrl2 = fetchUrl myCallback 

// test
let google = fetchUrl2 "http://www.google.com"
let bbc    = fetchUrl2 "http://news.bbc.co.uk"

// test with a list of sites
let sites = ["http://www.bing.com";
             "http://www.google.com";
             "http://www.yahoo.com"]

// process each site in the list
sites |> List.map fetchUrl2 
```

--------------------------------

### Floating point literal examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/cli-types.md

Examples of F# floating point literals: float32 with 'f' suffix, default float, and decimal with 'm' suffix.

```fsharp
123.456f
```

```fsharp
123.456
```

```fsharp
123.456m
```

--------------------------------

### Creating collections with List.init, comprehensions, and literals

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/list-module-functions.md

Demonstrates initializing lists using the List.init function, list comprehension syntax, and literal definitions for both lists and arrays.

```fsharp
// using list initializer
let listInit1 = List.init 5 (fun i-> i*i)
// val listInit1 : int list = [0; 1; 4; 9; 16]

// using list comprehension
let listInit2 = [for i in [1..5] do yield i*i]
// val listInit2 : int list = [1; 4; 9; 16; 25]

// literal 
let listInit3 = [1; 4; 9; 16; 25]
// val listInit3 : int list = [1; 4; 9; 16; 25]

let arrayInit3 = [|1; 4; 9; 16; 25|]
// val arrayInit3 : int [] = [|1; 4; 9; 16; 25|]
```

--------------------------------

### Pseudo-code for getPurchaseInfo

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-6.md

Initial pseudo-code showing the intended flow: open API, get product IDs, then get product infos. The `productInfosResult` is a placeholder.

```fsharp
let getPurchaseInfo (custId:CustId) : Result<ProductInfo list> =

    // Open api connection       
    use api = new ApiClient()
    api.Open()

    // Get product ids purchased by customer id
    let productIdsResult = api.Get<ProductId list> custId

    let productInfosResult = ??

    // Close api connection
    api.Close()

    // Return the list of product infos
    productInfosResult
```

--------------------------------

### Output for largestPageSizeM_AR with good sites

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/elevated-world-5.md

Example console output showing sequential execution for valid sites.

```text
[google.com] Started ...
[google.com] ... finished
[bbc.co.uk] Started ...
[bbc.co.uk] ... finished
[fsharp.org] Started ...
[fsharp.org] ... finished
[microsoft.com] Started ...
[microsoft.com] ... finished

SUCCESS: [bbc.co.uk] Content size is 108510
largestPageSizeM_AR_Good: Average time per run:  1026ms 
```

--------------------------------

### Integer literal examples

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/cli-types.md

Examples of F# integer literals with their suffixes: y, uy, s, us, u, L, UL, I. Also includes hex and octal prefixes.

```fsharp
99y
```

```fsharp
99uy
```

```fsharp
99s
```

```fsharp
99us
```

```fsharp
99
```

```fsharp
99u
```

```fsharp
99L
```

```fsharp
99UL
```

```fsharp
99I
```

```fsharp
0xFF
```

```fsharp
0o377
```

--------------------------------

### Searching List Elements and Indices

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/list-module-functions.md

Examples demonstrating the use of List.find, List.findBack, List.findIndex, and List.findIndexBack. Note that these functions throw a KeyNotFoundException if the item is not found.

```fsharp
let listOfTuples = [ (1,"a"); (2,"b"); (3,"b"); (4,"a"); ]

listOfTuples |> List.find ( fun (x,y) -> y = "b")
// (2, "b")

listOfTuples |> List.findBack ( fun (x,y) -> y = "b")
// (3, "b")

listOfTuples |> List.findIndex ( fun (x,y) -> y = "b")
// 1

listOfTuples |> List.findIndexBack ( fun (x,y) -> y = "b")
// 2

listOfTuples |> List.find ( fun (x,y) -> y = "c")
// KeyNotFoundException
```

--------------------------------

### Install NuGet package for F# script

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/low-risk-ways-to-use-fsharp-at-work.md

Run this command in your script directory to install a NuGet package, excluding the version to allow updates without breaking existing code.

```bash
nuget install FSharp.Data -o Packages -ExcludeVersion
```

--------------------------------

### Verify FsCheck installation with a property test

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/property-based-testing.md

Defines a simple property that reversing a list twice returns the original list, and runs it with Check.Quick. If no errors are shown, the installation is working correctly.

```fsharp
let revRevIsOrig (xs:list<int>) = List.rev(List.rev xs) = xs

Check.Quick revRevIsOrig 
```

--------------------------------

### Compare constructor and standalone function signatures

Source: https://github.com/swlaschin/fsharpforfunandprofit.gitbook/blob/master/posts/classes.md

Demonstrates that constructor signatures use 'new' and tuple parameters, contrasting them with standalone function signatures.

```fsharp
// class constructor signature
new : intParam:int * strParam:string -> MyClass

// standalone function signature
val new : int * string -> MyClass
```
Tokens:
Raw