Back to Questions
1.9k
views1
comment
Objects-related questions
f#classes

Hi,

I have a few questions :

regarding objects, it seems that, contrary to OCaml where there's no real inheritance but subtyping instead, classes in F# are dealt in a hierchacical way rather than in a structural way, i.e.

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

 

type a = 
  class
    new() = {}
    member x.foo() = print_int "my name is a"
  end

type b = 
  class
    new() = {}
    member x.foo() = print_int "my name is b"
  end

won't yield compatible classes. I was thus wondering if there was a way to have something like this :

1
2

val inline ( .[] ) :
  ^f -> 'a -> 'b when ^f : (static member get_Item : ^f * 'a -> 'b)

applied to classes with non-static fields, like :

1
2
3
4
5
6
7
8
9
10
11

 

type a = 
  class 
    new() ={} 
    member x.exec()=print_int 5 
  end ;;

// the following doesn't work
let inline f (x : ^a) = ( ^a : (member exec : unit -> unit) (x)) ;;

which would be equivalent to OCaml's 

1
2
3
4

 

let f (x : <exec : unit -> unit; .. >) = x#exec ()

================================================

Secondly, regarding interfaces, I was wondering why the following won't work :

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

 

type IFoo =
  interface
    abstract member exec : unit -> unit
  end

type DoingFoo =
  class
    new() = {}

    interface IFoo with
      member x.exec () = print_string "I interface foo"
    end
  end

let x = new DoingFoo() in x.exec() ;;

  x.exec() ;;
  --^^^^^

stdin(53,2): error: FS0039: The field, constructor or member 'exec' is not defined.

stdin(0,0): error: FS0039: The value or constructor 'it' is not defined.
stopped due to error

================================================

Last, using the #light syntax, it seemed that some declarations needed the following blocks to be offset (I think it was type foo = interface ... end) while others (e.g., if... then...else were fine with aligning). Are there some rules as to the offset required by the different parts of the syntax ?

Thanks a lot !!!

.

Yes, the OCaml object system is structrual, while the F# and .NET object systems are nominal.

In principle member constraints can be used in the way you describe. However, member constraints are really only currently for use in the F# library, particularly for operator overloading. So using them extensively is not recommended. This is also because of the restrictions related to inlining, which in particular means member constraints can't be associated with the type paramaters of classes.

Your second example needs to be 

1
2
3
4
5
6

 

let x = new DoingFoo();;
(x :> IFoo).exec() ;;

That is, interface members aren't automatically visible on class types - the interface must be explicitly revealed.

Re #light: yes, a detailed set of rules is in progress, and the particular problem with "else" that means that the following block does not need to be indented has already been noted. Please send us bug reports of any oddities.

Cheers!

don

By on 10/22/2006 1:53 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