Question

I really often use:

try
  try
  with
finally

so I’m interesting if is possible to make new syntax operator to not write “try” two times.

let mytry foo bar foobar =
  try 
    try 
      foo
    with 
      | _ -> bar // weird part here, I want to have a match
  finally foobar

mytry 
  <| foo
  <| | :? SocketException -> 
     | _ -> // ok it looks funny but how to realize it?
  <| foobar

the problems I see here are

• non-common syntax, in mytry there is no try with finally keywords, just <| <| <| for each, but it’s lesser trouble I guess
• with: I don’t know how can I realize this part. even how it will look if I can realize it…

Answer 1

The question is whether you really need try/finally. Most of the time try/finally is used for disposing resources even when exceptions occur. But you can always replace it by the use keyword.

For example:

open System.IO

let openFile(url: string) =
    let fileStream = File.OpenText(url)
    try
        try
          let readline = fileStream.ReadLine()
          printfn "Readline: %s" readline
        with
            | :? IOException as ex -> 
                     printfn "IOException: %A" ex
            | ex ->  printfn "Another exception: %A" ex
    finally
        fileStream.Dispose()

can be rewritten as:

let openFile(url: string) =
    use fileStream = File.OpenText(url)
    try
        let readline = fileStream.ReadLine()
        printfn "Readline: %s" readline
    with
        | :? IOException as ex -> 
                 printfn "IOException: %A" ex
        | ex ->  printfn "Another exception: %A" ex

For the learning purpose, you can define mytry using high-order functions as follows:

let mytry foo bar foobar =
  try 
    try 
      foo ()
    with 
      | exn -> bar exn
  finally foobar ()

But it doesn’t look really nice on above example:

let myOpenFile(url: string) =
    let fileStream = File.OpenText(url)
    mytry (fun () -> let readline = fileStream.ReadLine()
                     printfn "Readline: %s" readline)
          (fun ex -> match ex with
                     | :? IOException -> 
                            printfn "IOException: %A" ex
                     | _ -> printfn "Another exception: %A" ex)
          (fun () -> fileStream.Dispose())