Back to Questions
1.1k
views5
comments
Straight to a discriminated union type from an object in a pattern match?
f#

Is there a way in a pattern match to go straight from an obj to a discriminated union?

type A =
| Foo of int
| Bar of float

let a = Foo(1) :> obj

match a with
| :? A as aa -> // HERE
match aa with
| Foo i -> Some i
| Bar i -> Some i

Something like this, maybe (but this isn't it):

| Foo ( :? A as aa ) ->

| Bar ( :? A as aa ) ->

.

Is there a way in a pattern match to go straight from an obj to a discriminated union?

type A =
| Foo of int
| Bar of float

let a = Foo(1) :> obj

match a with
| :? A as aa -> // HERE
match aa with
| Foo i -> Some i
| Bar i -> Some i

Something like this, maybe (but this isn't it):

| Foo ( :? A as aa ) ->

| Bar ( :? A as aa ) ->

change the match to be like this:

1
2
3

match unbox<A>(a) with
| Foo i -> Some i
| Bar i -> Some i

Note this will throw an exception if a is not actually of type A

By on 3/17/2009 6:56 PM ()

change the match to be like this:

1
2
3

match unbox<A>(a) with
| Foo i -> Some i
| Bar i -> Some i

Note this will throw an exception if a is not actually of type A

Trying to avoid the exception handling here - I'd like to just do the match without a try block. I assumed there was some bit of syntax that I was just missing, but maybe there's no way around the two-step solution.

Why an unbox instead of a :?> downcast, like match a :?> A with ...? Is there a difference here?

By on 3/17/2009 8:03 PM ()

Hi,
I guess that match <b>unbox<A>(a) with</b> ... will work just fine in most of the cases, but it means slightly different thing. In particular, you cannot use this if you want to match the value "a" against two different discriminated unions. Interestingly, this can be done using quite simple active pattern (I'm always amazed how many things you can do with them!) <code lang=fsharp> let (|Cast|_|) (x:obj) : 'a option = match x with | :? 'a as a -> Some(a) | _ -> None;; // Now you can write something like this: match a with | Cast(Foo n) -> n // A.Foo | Cast(Bar n) -> n // A.Bar | Cast(Some o) -> o // Option<int>.Some | _ -> 0 // of course, this is incomplete match </code> T.

By on 3/18/2009 4:39 AM ()

I just use box / unbox as a matter of habit when dealing with obj's. To me it makes the code more readable, in the sense that you can tell at a glance by looking at the code that the thing there is an obj, because otherwise box / unbox isn't even legal to do. It also goes along with the practice of using the strictest possible language construct for the job, so that the compiler is more likely to catch it when you do something you didn't intend.

That being said, no matter what you do you're either going to have to handle the case where the it's not of the expected type, or assume that that case will never happen because you've made sure by other means that the thing there is always of type A. If you're assuming it will never happen, then you might as well use a construct that throws an exception and just not catch the exception since it iwll never happen, and if you are handling it, then whether or not you handle it with a try or some other mechanism is basically the same.

Also, in your original example it will also throw, just that it will throw a MatchFailureException instead of a casting exception if it's not of type A. I guess you could argue that adding a catchall handler at the end of the match block (i.e. | _ -> (*do something*)) is more readable and more "functional" than the box/unbox method.

By on 3/17/2009 9:23 PM ()

Also, in your original example it will also throw, just that it will throw a MatchFailureException instead of a casting exception if it's not of type A. I guess you could argue that adding a catchall handler at the end of the match block (i.e. | _ -> (*do something*)) is more readable and more "functional" than the box/unbox method.

You're right - I had chopped down the example and got rid of part that was matched if the object was another type, since I was just trying to figure out if there was a way to go straight to an instance of a discriminated union.

For this kind of thing, I do think that the | _ -> (*do something*) approach is better than the try approach. If you've got this kind of logic (Do *whatever* if you've got something that's of type A, do nothing otherwise) I think it's cleaner not to introduce exceptions.

By on 3/17/2009 10:23 PM ()

    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