Back to Questions
662
views1
comment
Simulate different result types for pattern matching
f#

Hi All

I'm trying to do something like that (very simplified):

1
2
3
4
5
6
7
8
9
10

type Model = 
  | Model1 of int
  | Model2 of double
  | Model3

let GetFunc (m: Model) = 
  match  m with
  | Model1 i -> fun (x: int, y: int) -> i
  | Model2 d -> fun (x: int, y: double) -> d
  | Model3 ->   fun (x: int) -> true

Of course this code does not complied due to type mismatch.

So the question is how to best implement this behavior in F# (maybe w/o pattern matching)?

I know how to do this in C# with inheritance and generics

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

  public abstract class ModelBase<TIn, TOut>
  {
    internal abstract Func<TIn, TOut> GetFuncInternal();
  }

  public class Model1 : ModelBase<Tuple<int, int>, int>
  {
    private int _val;
    public Model1(int val)
    {
      _val = val;
    }

    internal override Func<Tuple<int, int>, int> GetFuncInternal()
    {
      return _ => _val; 
    }
  }

  public class Model2 : ModelBase<Tuple<int, double>, double>
  {
    private double _val;

    public Model2(double val)
    {
      _val = val;
    }

    internal override Func<Tuple<int, double>, double> GetFuncInternal()
    {
      return _ => _val;
    }
  }

  public class Model3 : ModelBase<int, bool>
  {
    internal override Func<int, bool> GetFuncInternal()
    {
      return _ => true;
    }
  }

  public static class Helpers
  {
    public static Func<TIn, TOut> GetFunc<TIn, TOut>(ModelBase<TIn, TOut> model)
    {
      return model.GetFuncInternal();
    }
  }
.

I don't what exactly what you are trying to do.

But as you noted the code does not compile due to type mismatch.

But I'd guess that if you want to match against 

1
2
3
4

type Model  = 
| Model1 of int
| Model2 of double
| Model3

Then you should have 

1
2
3
4

type ModelResult =
  | ModelResult1 of (int * int -> int)
  | ModelResult2 of (int * double -> double)
  | ModelResult3 of (int -> bool)

as return from the match statement

so your code becomes : 

1
2
3
4
5

let GetFunc(m:Model) = 
    match m with
    | Model1 i -> ModelResult1(fun (x,y) -> i)
    | Model2 d -> ModelResult2(fun (x,y) -> d)
    | Model3 -> ModelResult3(fun x -> true)

You'll have to pattern match result and call and then call the function.

By on 11/8/2010 11:30 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