Slashdot Mirror

← Back to Stories (view on slashdot.org)

F# - A New .Net language

Posted by michael on from the no-tuning-fork-needed dept.

Goalie_Ca writes "Neonerds.net has learned of an implementation of the ML programming language for the .NET Framework. F# is essentially an implementation of the core of the OCaml programming language . F#/OCaml/ML is a mixed functional-imperative programming language which is excellent for medium-advanced programmers and for teaching. In addition, you can access hundreds of .NET libraries using F#, and the F# code you write can be accessed from C# and other .NET languages. See the F# Homepage."

4 of 213 comments (clear)

  1. Support for .NET generics by Jabes · · Score: 2, Informative
    From the web page:


    F# also happens to be the first released .NET language that is able to produce Generic IL, and the compiler was really designed with this target language in mind. However the compiler can also produce standard .NET binaries, which is just as well because there is no publicly available release of a .NET Common Language Runtime for .NET that supports generics.


    So it looks like there are releases of Microsoft's jitter that have full support for execution-time expansion of generics. I can't wait!
  2. Comment removed by account_deleted · · Score: 3, Informative

    Comment removed based on user account deletion

  3. Languages - an art form by ndogg · · Score: 2, Informative

    I see a few people complaining that there is "yet another language to learn."

    They ask, "Why bother creating another language? There is quite a number of them out there. Any of them should be able to solve almost any problem out there."

    Programming languages are an art form, and like any other art form, it deserves respect. Each programming language forces a programmer to think about a problem in a slightly different manner. Prolog forces a programmer to think in terms of goals to be achieved, and OO languages force a programmer to think in terms of self contained parts of the problem. Different programming languages make it easier to solve different types of problems. Haskell is a great language to represent infinite sequences due to its use of lazy evaluation.

    Would you tell a musician to not experiment with sounds not created by traditional instruments because there are so many musical instruments out there for him/her to use, and that any musical piece can be performed with any of them? Musicians come up with new sounds all the time because those new sounds allow them to view music from another perspective

    --
    // file: mice.h
    #include "frickin_lasers.h"
  4. Re:To destroy languages is the power of .NET by curri · · Score: 2, Informative

    A few things (this is not a flame, your ideas seem reasonable enough :)

    1. virtual In java (If I understand correctly) EVERY method is virtual. So you may not like the idea of non-virtual methods. They are there for performance. You can, of course, just declare all your methods virtual :)

    2. Multiple inheritance is a more powerful mechanism, compared with interfaces. If you use pure-virtual classses, it can be equivalent to interfaces (although you can still attach some code), but it can do more.

    The standard example is when you have 2 separate class hierarchies (sp?), and need to have a class that belongs to both. Say you have a GUI framework, and a persistence framework and want a persistent window :)

    IF you had the code for both frameworks, you could probably change some things for interfaces.

    My problem with interfaces is that they only pass type info, but no code; they make for a cleaner mechanism, but if you actually need to get code from 2 different classes you're screwed.

    It may just be philosophical differences; I like the philosophy behind C++ (the programmer knows what (s)he wants to do, it's not the language's problem if they don't), and felt Java as taking things away because they're dangerous :)

    3. Pointers/memory management It is nice to have garbage collection, and memory issues in C++ get to be more complicated. But you get more flexibility, performance and destructors :)

    It's not that hard to mix pointers and instances most of the times. You would never delete an instance, of course, and very few times take the address of an instance (there are references in C++ now; it's not C). Also, you can use auto_ptr and all those goodies.