Back to Questions
1.1k
views1
comment
Tuple types vs. record types and deprecated declaration forms.
f#compiler

Hello All,

I have developed quite a substantial body of code in F# creating a framework to deal with source code in the X++ programming language (which is a superset of Java with built in strong database functionality). Originally I modeled the AST as union types, like so:

1

type XppClass = Class of string * string option * string list

expressing that a class consists of a name, an optional extension and a list of implemented interfaces (the example is obviously scaled down from the real code, but will serve in the subsequent discussion). This was fine until it became a requirement that the resulting trees be consumed from C#; the names chosen by the F# compiler for the values in the union do not convey much meaning. I then went forth and added names to the individual fields using the syntax:

1

and  NewXppClass = Class of {name: string * extends: ident option * implements: ident list }

which was fine until I installed the newest version of F# (the CPR version). Here, the compiler warns that ”this form is deprecated”, and that a record type should be used instead. The problem is that a record type, like

1

and XppClassRecord = {Name: string ; Extends: string option ; Implements: string list }

does not allow positional syntax anymore. It is not possible to write 

1

let v = {"MyClass"; Some "object"; []}

or something to that effect (but of course

1

let v = {Name="MyClass"; Extends=Some "object"; Implements=[]}


is fine).

The latter of the two values above is obviously more readable than the former, but I cannot afford to change the existing large codebase to this syntax.

I have tried to solve the problem by introducing the active pattern

1
2

 
let (|XppClass|) recval = Class( recval.Name, recval.Extends, recval.Implements)

in the hope that it would solve the problem where

1

… match c with Class(n,_,_) …

Is applied with a value of type XppClassRecord but in this case the syntax needs to be changed to 

1

… match c with <B style="mso-bidi-font-weight: normal">XppClass(</B>Class(n,_,_)) …

To compile correctly.

I guess the questions are:

Why is the syntax 

1

Type NewXppClass = Class of {name: string * extends: ident option * implements: ident list }

deprecated, and

why is the extra XppClass() needed around the expression in the match: Surely the compiler can infer that Class is of the type XppClass?

I promise that this will be my last post this year. Let us hope that F# will fulfill its huge promise in the new year. Happy new year to all.

Best Regards

Peter Villadsen

.

What's wrong with:

1
2
3
4
5
6
7

type XPPClass = 
   val name : string
   val extends : string option
   val implements : string list
   new( n, e, i) = { name = n; extends = e; implements = i }</B><B>

let c = XPPClass( </B>"Foo"<B>, Some </B>"FooBase"<B>, [</B>"IFoo"<B>] )

You'll need to use an explict c'tor, but you still have positional arguments. (I think the explict c'tor is quite a bit nicer as well.)

thanks,
m

By on 1/15/2009 2:44 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