let isBob name =
  match name with
  | "bob" -> "It's bob!"
  | _ -> "It's not bob!"

let isName1 matchName personName =
  match personName with
  | personName ->
    sprintf "It's %s!" matchName
  | _ ->
    // This rule will never be matched...
    sprintf "It's not %s!" matchName

let isName2 matchName personName =
  match personName with
  | str when str = personName ->
    sprintf "It's %s!" matchName
  | _ ->
    sprintf "It's not %s!" matchName

let (|Eq|_|) expected value =
  if expected = value then Some ()
  else None

let niceIsName matchName personName =
  match personName with
  | Eq matchName ->
    sprintf "It's %s!" matchName
  | _ ->
    sprintf "It's not %s!" matchName

let (|Val|_|) = Map.tryFind

let makeForwarder =
  function
  | Val "type" "db" & Val "connection" conn ->
    dbForwarder conn 
  | Val "type" "console" & Val "prefix" prefix ->
    consoleForwarder prefix
  | _ -> failwith "wat?"

let (|AsInt64|_|) s =
  match Int64.TryParse s with
  | true, v -> Some v
  | _ -> None

match "1234" with
| AsInt64 x -> "ok"
| _ -> "not ok"

let tryGetPort hostName config =
  match config with
  | Val hostName (AsInt64 portNum) -> Some portNum
  | _ -> None

open FSharp.Quotations
open FSharp.Quotations.ExprShape

let expr = <@@ if 10 < 5 then "really?!" else "good" @@>

let rec traverse expr =
  match expr with
  | ShapeVar (v) ->
    Expr.Var(v)
  | ShapeLambda(v, body) ->
    Expr.Lambda(v, traverse body)
  | ShapeCombination(a, args) ->
    let traversed = args |> List.map traverse
    ExprShape.RebuildShapeCombination(a, traversed)

let result =
  if expr = traverse expr then "Hurrah!" else "Boo!"

open Swensen.Unquote.Assertions

let test1() =
  test <@ 1 = 2 @>

test1()

let test2() =
  test <@
    [3;2;1;0]
    |> List.map ((+) 1)
    |> (=) [1 + 3..1 + 0]
  @>

test2()

open FSharpComposableQuery

type Person = { name: string; age: int }

let people = [
    { name = "bob"; age = 25 }
    { name = "fred"; age = 27 }
  ]

let aQuery =
  query {
    for p in people do
      sortBy p.age
      last
  }

let filter = <@ fun (p : Person) -> p.age < 27 @>

let q2 filter =
  query {
    for p in people do
      if (%filter) p then yield p
  }

let filtered = q2 filter

type OptionBuilder () =
  member x.Bind(m, f) =
    match m with
    | Some value -> f value
    | None -> None
  member x.Return value =
    Some value

let option = OptionBuilder()

let maybeAdd maybeA maybeB =
  option {
    let! a = maybeA
    let! b = maybeB
    return a + b
  }

// None
maybeAdd (Some 10) None

// Some 20
maybeAdd (Some 10) (Some 10)

open Hopac

let workToDo = job {
    let! a = job { return 10 }
    let! b = async { return 10 }
    return a + b
  }

let workDone = Job.Global.run workToDo

type AsyncBuilder with
  member x.Bind(aJob : Job<'a>, f : 'a -> Async<'b>) =
    job {
      let! jobResult = aJob
      return! f jobResult
    } |> Extensions.Async.Global.ofJob

let asyncWorkToDo = async {
    let! a = job { return 10 }
    let! b = async { return 10 }
    return a + b
  }

let asyncWorkDone = asyncWorkToDo |> Async.RunSynchronously

open FSharp.Text.RegexProvider

type MyRegex = Regex<"""(?<name>.+):\s+(?<age>\d+)""">

let regexed = MyRegex().Match("Bob McBob: 42")

let bobMcBob =
  { name = regexed.name.Value
    age = regexed.age.Value |> Int32.Parse }

let (|IsMatch|NotMatch|) str =
  match MyRegex.IsMatch str with
  | true -> IsMatch (MyRegex().Match(str))
  | false -> NotMatch

let (|AsInt|_|) str =
  match Int32.TryParse str with
  | true, i -> Some i
  | false, _ -> None

let (|StringToPerson|_|) str =
  match str with
  | IsMatch regexed ->
    match regexed.age.Value with
    | AsInt i -> { name = regexed.name.Value
                   age = i } |> Some
    | _ -> None
  | NotMatch -> None