2.0k
views2
comments

Hi List!

I have finally come to get into a .NET-project and therefore am now able to take a deeper look into F#.

What I especially like in the language is, apart from the beautiful syntax[1], that it offers the features of a functional language without forcing the programmer into a functional style of programming. Coming from the Java-world I am used to the object-oriented style, which I not only know best but use all the time at work. I have some questions that I came upon while writing small programs during a deadly lame C#-course. Sorry if some of the points discussed here have been discussed before.

1. Inheritance and interface implementation

If I define an abstract class using abstract members (is there a way or the necessity to mark a class with abstract members itself as abstract? If not, this might be a good idea for the sake of clarity) and inherit this class, I am not bashed by the compiler when not implementing these abstract members. Is that intended? If yes, this would mean I have to see this subclass as abstract as well, what is not visible within the class definition. At this point, a necessity for some hint on this manner should be much appreciated. Same "problem" applies to the implementation of interfaces as well.

Within class libraries, there is a common pattern of creating an interface, have an abstract class inherit from that, leaving some or all of the interfaces members abstract and then writing concrete classes for implementation. I have failed in finding a way to do that in F# so far. I can create interfaces and classes with abstract members and inherit from them but the abstract class implementing an interface with abstract members didn't work out.

I am aware of the fact, that there is a possibility for the nonexistence of abstract classes in the sense of the word from a Java/C#-perspective within F#, leaving abstract as a member-level-only concept. If that's the case, please tell me.

2. (Readonly) Vals in classes

Are vals in classes private? Using vals from other classes directly, the compiler doesn't complain at all. Is this an error or is there a possibility to mark vals as private?

In many cases I want a val to be not mutable but it's initial value depends on other values previously set within the constructor. I get a warning that the initialization can not be checked for soundness at compile time and am referred to using the "then" clause instead. Unfortunately, this leaves me helpless with my non mutable values as they have to be assigned a value within the constructor expression and then to be modified to the correct value afterwards. This is somewhat awkward.

3. Next time, try with finally! ([:)])

When I want to read a file within C#, I am well advised to do the stream handling in a try block, catching exceptions with a catch block and close streams and writers in a finally block. However, I stumbled across the fact, that F# would seem to have only try-with and try-finally statements and no try-with-finally. How should such file handling code be written then? Another point is the let statement for this. As I have to assign a value as soon as I have the let (which obviously makes sense) I cannot (as I would do in C#) declare a variable, working with that in the try and have it available still when within the finally block. I ended up writing something like that:

try
   try
       let stream = File.Open (...)
       let writer = new StreamWriter stream

   // do writing
   finally
       writer.Close ()
       stream.Close ()
with
   // Exception handling

Is that correct? (Not so sure about that being very beautiful, however)

4. decimal

The decimal "primitive" type seems to have been thought of (and is obviously reserved within the language therefore). That actually would be nice it would seem, as it simplifies working with that type of numbers.

[1] Some years ago, I read some articel about OCaml stating the syntax of this language as to be "baroque". This surely was not meant too positive, but while I have a deep love for baroque music, I also appreciate this syntax very much for it's shortness and clarity as well as it's lacking overuse of special characters (although F# has the unfortunate tendency to break with that idea) - try writing braces all the time using a german keyboard layout!

1. you need not mark the class as abstract. However, if your class contanis one or more abstract members, the compiler will warn you. Likewise, if you inherit from a class with abstract members, and if you don't provide the child with an implementation for all abstract members (ie if some abstract members from the parent are not implemented by the child), the compiler will warn you too.

2. val are not hidden. They're equivalent to plain member with get, set.You can have private members using let bindings instead of val, as in :

 
type foo() =
  let x = 5
  member x.run() = print_int x

For your value that depends on other values, it depends on whether it depends on member values or on values passed to the constructor... An example fo what you want could help.

3. the following syntax does what you want (ie dispose the stream when you're done with it)

try
  use stream = File.OpenWrite("...")
  use writer = new StreamWriter(stream)
  ...
with
  _ -> print_string e.Message

By Julien on 11/8/2007 6:56 AM (permalink)

1. I think, a warning is a somewhat weak thing in this regard, because a missing implementation for something abstract inherited is an error. If there is no need for marking a class as abstract, it is not possible to see if a class is abstract if it implements an interface that's code is currently not visible.
What about the interface-abstract class-concrete class chain? What I wish to achieve is the equivalent to the following:

public interface IMyStuff
{
    public string MyProperty { get; set; }
    public void MyMethod();
}

public abstract class MyStuff : IMyStuff
{
    private string _myProperty = "";
    public string MyProperty { get { return _myProperty; } set { _myProperty = value; } }
    public abstract void MyMethod();
}

public class VerySpecialStuff
{
    public override void MyMethod() { do something ... }
}

2. The let bindings don't work out that well in classes, it would seem. I am referred to implicit construction sequences instead, where it is not implemented yet to have vals declared. Also, I prefer the ides of having the constructor parameters left with the constructors instead of putting them directly to the class definition. That avoids name clashes and gives more flexibility to the constructors. Why can't we just either have all vals be private (one can still write properties for those to be visible publicly) or at least the possibility to declare them likewise?

3. Ah cool. So the runtime takes care for that. How nice.

5. Calling .NET APIs
Naturally, much of the code being written in F# is making calls to the .NET API. I read somewhere that the arguments can be passed as tuples or in "normal" space separated style. This doesn't seem to be the case. When I try to call methods with more that one parameter, I am forced to use the tuple-style parameter passing. Is that true and why is it like that?

6. Light indentation problems
I like the #light option very much. But I have to admit that I sometimes wish for a bit more flexibility there. For example, when writing methods, that use pattern matching, I often would rather write

1
2
3

member this.DoSomethingWith parameter = match parameter with
 | whatever -> ...
 | _ -> ...

instead of having to put the "match parameter with" on the new line. When writing constructors with a then clause it will sometimes (not always) even force me to write everything up to the "then" on one line. When I changed a member writing a "private" in front of it, it had me indenting the method body two levels further without reason.
I don't know how much more flexibility could be provided there but I shall appreciate every improvement.

7. Calling constructors within constructors
Is it possible to call another constructor of the same class from a constructor? Currently, I find myself being forced to copy large "then" clauses of constructors to all of them or have them factored into a method. By the way: why is the syntax for constructors so "C#-ish" with needing parentheses, enclosing braces and semicola?

By Josquin on 11/9/2007 7:44 AM (permalink)

Topic tags

Built with WebSharper

Home

Answers

Events

Courses

Groups and Conferences

Blogs

Jobs

Developers

Topic tags