What features would you add, remove or change in F#?

Question

I've been reading and coding in F# as a hobby for a year now. As I prepare to deploy some code in production, I would like to hear what the SO community thinks could be improved in the language, and hopefully have the F# Team take some ideas from this thread and implement them in future releases.

One feature per answer would make it easier for the community to upvote you.

Edit: should I place my suggestions here or with the answers down there?

Answer 1

In F#, I would change the syntax for tuple types, from the awful ML

'a * 'b

to the beautiful Haskell

('a,'b)

Similarly, I would rename 'unit' to '()'. ML got it ugly, and Haskell came along later and made it pretty. Alas, F# is an ML derivative and this will never change.

Answer 2

I would get rid of the ML-style generic types like

'a list
('key,'value) Dictionary

in favor of only having the .Net style type names like

list<'a>
Dictionary<'key,'value>

Alas, F# is an ML derivative and this will never change.

Answer 3

I would make the let keyword optional when using #light syntax, meaning by default. It is perfectly understandable for me to write:

let squares = [1..5] |> Seq.map (fun x -> x * x)

As it is to write:

squares = [1..5] |> Seq.map (fun x -> x * x)

For a language that attempts to reduce the signal-to-noise ratio, I think we could do without let.

Edit: moved the fun suggestion into its own answer.

Answer 4

I think this has been discussed before and it's probably not going to happen, but I have to ask for it anyway.

Implicit type conversion among compatible types, so that we are able to do:

let a = 3
let b = 4L
let c = a + b

..without having to cast it.

Answer 5

I also would like to have something like Mixins. I often find myself typing Seq.xxx a lot of times and I always felt weird calling what look like static methods. With Mixins we could do:

import Seq

let oddSquares = [1..10] |> map (fun x -> x * x) |> filter (fun x -> x % 2 <> 0)

Which seems more functional in my opinion. And if we combine it with my other suggestions we'd get:

oddSquares = [1..10] |> map (x -> x * x) |> filter (x -> x % 2 <> 0)

That's less noise and more signal, no?

Answer 6

Allow

let a = 3
    b = 4

instead of

let a = 3
let b = 4

Answer 7

Remove the need to downcast to interfaces in order to access their members. For example allow

type Foo =
    abstract Lol : int -> int

type Bar() =
    interface Foo with
        member x.Lol i = i * i

let x = Bar()
x.Lol 0

That would improve .NET integration a lot and remove some tremendously ugly parenthesized downcast. Anyway don't know why but I've got this bad feeling that we're not gonna see this :(

Answer 8

If the compiler could just be tweaked to infer thoughts as well as types...

Answer 9

Bind member selection more tightly than function application; e.g., this:

let x = "10"
printfn "%i" Int32.Parse( 10 )

rather than this:

let x = "10"
printfn "%i" (Int32.Parse( 10 ))

Answer 10

I would make the fun keyword optional when using #light syntax, meaning by default. It is perfectly understandable for me to write:

let squares = [1..5] |> Seq.map (fun x -> x * x)

As it is to write:

let squares = [1..5] |> Seq.map (x -> x * x)

For a language that attempts to reduce the signal-to-noise ratio, I think we could do without fun.

Answer 11

How about some default casting of literals by using an already inferred type.

Let mutable a = 1.0f
a <- 0

instead of

Let mutable a = 1.0f
a <- float32 0

The compiler could just throw a warning about possible lost of data even though in this case it's not a problem.

Answer 12

I realize some of these aren't possible, but theres no harm in voicing some thoughts:

Statically-checked structural typing. For example, the function

let f x = x#someMethod()

Should accept any x so long as it has a method val someMethod : unit -> 'a.

Just one way to do it. I think in the beginning, OCaml compatibility was very important, leading to the development of a #light and non-light syntax, two mutually incompatible syntaxes for defining classes, and a bagillion different ways to define objects with generic parameters:

type 'a tree =
    | Node of 'a * 'a tree * 'a tree
    | Empty

type tree2<'a> =
    | Node of 'a * tree2<'a> * tree2<'a>
    | Empty

type tree3<'a when 'a :> System.IComparable<'a> > =
    | Node of 'a * tree3<'a> * tree3<'a>
    | Empty

type 'a tree4 when 'a :> System.IComparable<'a> =
    | Node of 'a * tree4<'a> * tree4<'a>
    | Empty

type ('a, 'b) tree5 =
    | Node of 'a * 'b * ('a, 'b) tree5
    | Empty

type tree6<'a, 'b> =
    | Node of 'a * 'b * tree6<'a, 'b>
    | Empty

type tree7<'a, 'b> when 'a :> System.IComparable<'a> and 'b :> System.IComparable<'b> =
    | Node

Now that #light is enabled by default and the F# library no longer cross-compiles with OCaml, we should consider OCaml compatibility no longer relevant. The language needs to be simplified.

Type signature should match type annotations: When I write a method like this:

let f (x : 'a :> #System.IComparable<'a>) = x

F# reports the type signature as val f : 'a -> 'a (requires 'a :> System.IComparable<'a>). I'd prefer to see the type signature reported exactly as written: val f : ('a :> #System.IComparable<'a>) -> 'a.

Intellisense should report variable names: Its hard to know what I'm calling when I can't see variable names. Case in point, F# lists the constructors for the StringBuilder class as follows:

val new : unit -> System.Text.StringBuilder
val new : int -> System.Text.StringBuilder
val new : string -> System.Text.StringBuilder
val new : string * int -> System.Text.StringBuilder
val new : string * int * int * int -> System.Text.StringBuilder
val new : int * int -> System.Text.StringBuilder

I've created a bagillion StringBuilders and know how to use most of these, but I keep having to go back to MSDN to figure out what exactly I'm passing in. I've figured out how to get constructor parameters by writing System.Text.StringBuilder;; into fsi, which gives me this output:

stdin(1,1): error FS0191: Invalid use of a type name and/or object constructor. If necessary use 'new' and apply the constructor to its arguments, e.g. 'new Type(args)'. Overloads are:  
    System.Text.StringBuilder() : unit
    System.Text.StringBuilder(capacity: int) : unit
    System.Text.StringBuilder(value: string) : unit
    System.Text.StringBuilder(value: string, capacity: int) : unit
    System.Text.StringBuilder(capacity: int, maxCapacity: int) : unit
    System.Text.StringBuilder(value: string, startIndex: int, length: int, capacity: int) : unit

Barring changes to Intellisense, I'd just like some way to quickly expore type signatures. C# has an interesting feature where I can press F12 on any class, like the StringBuilder class, and it'll pull up a window with the class's complete public signature similar to what fsi shows above. The object browser works for now, but its too slow and doesn't always show me all the information I'm interested in seeing (i.e. it doesn't show me an object's base class).

Functional alternatives to existing libraries: this probably isn't the responsibility of the F# team, maybe it should be an open source project, but the .NET libraries don't make functional programming very easy. Everything in System.Data, the Microsoft Enterprise Library, and some third-party libraries like NHibernate rely heavily on mutable state.

Answer 13

Remove the C style generic type parameter names from the F# library. 'T 'U 'T1 'T2? 'a and 'b are more readable and fit in with existing literature.

Answer 14

Allow \ and . for lambdas instead of fun ->:

let id = \x.x

Instead of:

let id = fun x -> x

Answer 15

Allow cross-file mutually recursive type definitions, or cross-file intrinsic type extensions.

Answer 16

Allow user code to use the same things the F# library can, like static optimizations:

> let inline map (f: ^a -> ^b) (xs: ^c) =
-   Seq.map
-   when ^c : ^b list = List.map
-   when ^c : ^b array = Array.map;;

    when ^c : ^b list = List.map
  -------^^^^^^^^^^^^

stdin(40,8): error FS0191: Static optimization conditionals are only for use within the F# library

Answer 17

No one has said typeclasses yet?

Answer 18

The ability to access protected members in lambdas. I can't figure out why it's a restriction, but it's annoying:

> type TestEx() =
-   inherit System.Data.DataException()
-   member x.ShowHR() = printfn "%A" x.HResult // This is fine
-   member x.Oops = fun () -> x.HResult // No? Why?
- ;;

    member x.Oops = fun () -> x.HResult // No? Why?
  ----------------------------^^^^^^^^^

stdin(19,29): error FS0191: The member or object constructor 'HResult' is not accessible. Private members may only be accessed from within the declaring type. Protected members may only be accessed from an extending type and may not be accessed from inner lambda expressions

Answer 19

Allow automatic upcast to return type, if specified. I know I might sound like a hypocrite given that I usually don't like automatic conversions, but I think if the type of the expression is explicitly specified with #, it'd be ok.

I don't want to have to do this:

let getEx n : Exception = 
  match n with 
  | 1 -> upcast OutOfMemoryException()
  | _ -> upcast ArgumentException();;

I want this to work:

> let getEx n : #Exception =
-   match n with
-   | 1 -> OutOfMemoryException()
-   | _ -> ArgumentException();;

    | 1 -> OutOfMemoryException()
  ---------^^^^^^^^^^^^^^^^^^^^^^

stdin(37,10): warning FS0064: This construct causes code to be less generic than indicated by its type annotations. The type variable implied by the use of a '#', '_' or other type annotation at or near 'stdin(35,14)-(35,24)' has been constrained to be type 'OutOfMemoryException'.

    | _ -> ArgumentException();;
  ---------^^^^^^^^^^^^^^^^^^^

stdin(38,10): error FS0001: This expression has type
        ArgumentException
but is here used with type
        OutOfMemoryException

Answer 20

OK, not a F# language feature, but having IntelliSense in ASPX pages would change my year.

Answer 21

Add shorthand syntax for (fun x -> x.Foo)

Answer 22

eval

Answer 23

Partial Classes.

First step in making a GUI builder :-)

Answer 24

Proper tools for non-#light syntax, like autoindentation.

Answer 25

Typesetting and visualization both in the source editor in Visual Studio and in interactive sessions. I want typeset maths and graphics in my code, comments and produced as output. Also, I want structured source code with collapsible headings and subheadings.

Answer 26

Better support for lexing and parsing

Firstly, F# should catch up with where OCaml already was:

• fslex and fsyacc should have integrated VS support as the equivalent OCaml tools do with OCaml editors like Emacs.

• fslex should support named subexpressions as ocamllex does, so you can match '"' ([^"]* as s) '"' and have s bound for you efficiently without having to do it inefficiently by hand using a separate regular expression.

Secondly, F# should take advantage of .NET to leapfrog the alternatives:

• These tools should all be available at run-time, generating and compiling CIL code on-the-fly like Regex does.

Answer 27

"use" bindings in implicit class constructors which would cause the class to automatically implement IDisposable with calls to .Dispose() for each "use" binding