Back to Questions
1.0k
views3
comments
When is an exception considered "unhandled by user code"?
f#

Hi,I'm seeing some strange "unhandled exceptions", causing Visual Studio to break into the debugger. What is strange is that the code _is_ actually in a try _ with block. When VS breaks with this exception, when I press F10 to step ahead, I actually see that the program continues with the "with" (catch) statement and furthermore proceeds as normal. I don't have "break on all exceptions" on.Code looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

let private safeForce (body:Lazy<_>) =
    try
          body.Value |>property
    with
          e -> liftResult (exc e)

let private evaluate body a : Property =
    let argument a res = { res with Arguments = (box a) :: res.Arguments }
    safeForce (lazy ( body a )) //this doesn't work - exception escapes??
//    try 
//        body a |> property
//    with
//        e -> liftResult (exc e)
    |> fmapGen (fmapRose (argument a))

Ignore all the stuff, unfortunately I haven't been able to distill a small example.In any case, if I use the commented code in evaluate, instead of the safeForce, everything works as expected (i.e. no unhandled exception). If I use the safeForce as written, if an exception occurs in 'body', VS breaks with an unhandled exception. The thing is that it breaks right inside the try _ with block in safeForce! Pressing F5 continues as nothing happened. (i.e. it continues to with, the exception is handled and everything proceeds)Any ideas? I'm thinking in circles here...thanks,Kurt

.

let div0 n =
n / 0;;

let safeDiv0 (n: Lazy<_>) =
try
printf "%d\n" (div0 (n.Force()))
with
e -> printf "Error %d\n" (n.Force())

if I run

safeDiv0 (lazy 5)

the error is handled.

However, if I run

safeDiv0 (lazy (div0 5))

I get

System.DivideByZeroException: Attempted to divide by zero.
at Microsoft.FSharp.Control.Lazy`1.UnsynchronizedForce()
at Microsoft.FSharp.Control.Lazy`1.Force()
at FSI_0005.safeDiv0(Lazy`1 n)
at <StartupCode$FSI_0007>.$FSI_0007._main()

It looks like F# isn't being very lazy about evaluating (div0 5).

So your error might be happening when (body a) is being evaluated as an argument, since F# seems to be doing that before (body a) is forced?

I can't get around this with

> let x = lazy (div0 5);;

val x : Lazy<int>

> safeDiv0 x;;
System.DivideByZeroException: Attempted to divide by zero.
at Microsoft.FSharp.Control.Lazy`1.UnsynchronizedForce()
at Microsoft.FSharp.Control.Lazy`1.Force()
at FSI_0005.safeDiv0(Lazy`1 n)
at <StartupCode$FSI_0011>.$FSI_0011._main()
stopped due to error

either. So maybe I'm doing something wrong here.

Or maybe F# forces a value when it is passed as an argument, and it's supposed to. I'm pretty confused at this point.

By on 2/26/2009 4:37 PM ()

You are calling n.Force() in the printout of the error, which will just raise the same exception again. Your 'with e' clause should print 'e', and then maybe things will be less confusing.

By on 2/26/2009 7:44 PM ()

Doh!

OK, throw out that theory...

By on 2/27/2009 5:33 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper