Back to Questions
2.9k
views2
comments
Discriminated Union case -- how to access the underlying type?
f#reflection

For my application (fantasy combat simulator), one of the outputs I receive is a tree-structured event stream that the user will use to understand what happened and why, like so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

let input = 

    Round(1,

        [�

        Fireball(ligam,

            [�

            ExpendMP(30, 20, state)

            TakeDamage(orc1,

                [�

                Result(FixedRoll(10,6), 57)

                LoseHP(10, -47, state)

                DeathCheckOK(AttemptOK(14, Result(OpenRoll(3,0), 9)))

                DeathCheckOK(AttemptOK(12, Result(OpenRoll(3,0), 11)))

                DeathCheckOK(AttemptOK(10, Result(OpenRoll(3,0), 4)))

                ])

            TakeDamage(orc2,

                [�

                Result(FixedRoll(10,6), 43)

                LoseHP(10, -33, state)        

                DeathCheckFail(AttemptFail(14, Result(OpenRoll(3,0), 15)), Death state)

                ])

            ])

        Miss(orc1, ligam,

            AttemptFail(11, Result(OpenRoll(3,0), 12)))

        ExertionFail(orc1,

            AttemptFail(11, Result(OpenRoll(3,0), 12)),

            Unconscious state)

        ])

Now, it turns out that although I can easily construct a context-free generative grammar for the event stream, it is not so easy to impose a type system that matches the grammar. So I end up with discriminated union that looks a lot like dynamic typing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

// this might be an abuse of the term "Nonterminal"--I'm not sure yet if we are really defining a CFG

type Nonterminal =

    // Probability resolution

    | OpenRoll of int * int

    | FixedRoll of int * int

    | Result of Nonterminal * int // roll spec, actual

    // Justifications

    | AttemptOK of int * Nonterminal // difficulty, result

    | AttemptFail of int * Nonterminal // difficulty, result

    // State changes

    | LoseHP of int * int * State

    | ExpendMP of int * int * State

    | Death of State

    | Unconscious of State

    // TakeDamage

    | TakeDamage of Name * Nonterminal list // victim, (LoseHP / DeathCheck) list

    | DeathCheckOK of Nonterminal // justification

    | DeathCheckFail of Nonterminal * Nonterminal // justification, state change

    // Action

    | Fireball of Name * Nonterminal list // agent, TakeDamage list

    | Hit of Name * Nonterminal * Nonterminal // agent, justification, TakeDamage

    | Miss of Name * Name * Nonterminal // agent, victim, justification

    // Followup

    | ExertionOK of Name * Nonterminal

    | ExertionFail of Name * Nonterminal * Nonterminal // target, justification, state change

    // Round

    | Round of int * Nonterminal list // round number, (Action / Followup) list

Now, all of this is okay for now. However, in some cases I know for sure what type of Nonterminal a given function is expected to handle, and I wish there were a way to express this as a type constraint, mostly for the sake of documentation but also so I don't have to re-decompose:

1
2
3
4
5

let FormatFireball (f : Nonterminal.Fireball) = ... // won't work, Fireball is not recognized as a class

match Nonterminal with
| Fireball(_, _) as f -> FormatFireball(f)
| ...

The perplexing thing is that reflection shows that there really is a Nonterminal.Fireball class at the CLR level, so presumably C# could write a FormatFireball method... but apparently F# can't. Is there any way around this problem or am I just stuck with doing pattern matching inside FormatFireball?

-Max

.

Did you know you can write

1

let FormatFireball (Nonterminal.Firebal(name, damages)) = ...

Moreover, your discriminated union looks a bit flat. What about

1
2
3
4
5
6
7

type Round = Round of int * ActionOrFollowup list
and ActionOrFollowup =
| Action of ...
| Followup of Exertion
and Exertion =
| ExertionOK of ...
| ExertionFail of ...

and so on...
The union should match your grammar, I don't understand why that's difficult.

By on 9/1/2011 7:44 AM ()

Followup: after some thought, it seems likely that discriminated unions are probably the root cause of the problem here. My current plan for refactoring is to promote Round, Fireball, etc. to concrete classes in OO style (CFG productions will be expressed as different ctors, e.g. Fireball(TakeDamage list)). The nice thing about discriminated unions is that they are automatically compatible with patterns--but in F# I can just define corresponding active patterns for each concrete class.

I may post more details after I get it working but that's the basic notion.

-Max

By on 8/31/2011 10:26 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