F# 4.0 Preview

http://blogs.msdn.com/b/fsharpteam/archive/2014/11/12/announcing-a-preview-of-f-4-0-and-the-visual-f-tools-in-vs-2015.aspx

by noblethrasher • 12 years ago

249 71 12 years ago

blogs.msdn.com

galago• 12 years ago

It would be useful if someone knowledgeable and critical could explain clearly the use of this language. The marketing blather doesn't give me much. I'm not a software engineer, so this just seems like a bunch of syntax wankery. I'm probably wrong, I'm just looking for a brief explanation as to why.

alkonaut2• 12 years ago

It's a functional language for the .NET platform.

So you'll want it if you want a functional language and you want to use the .NET platform.

Does that answer your question?

CmonDev5• 12 years ago

F# is a hybrid language just as C# is. Just a different flavour of the mix.

noblethrasher8• 12 years ago

Really short answer:

F# is to C# as C is to Assembler (I regularly use both C# and F# and don't quite agree with this, but it is defensible).

Short answer:

Programming, especially OOP, has a lot of prescriptions: things like coding against interfaces rather than implementations, using abstractions, the law of Demeter, avoiding mutations, prefer composition to inheritance, etc.

Basically, you can think of F# as a language that compiles down to C#, but follows all of the best practices without fuss.

Consider this example of F# code:

		type Shape =
			| Circle of float
			| Square of float

		let area s =
			match s with
			| Circle r -> Math.PI * r * r
			| Square sd -> sd * sd
			
		let perimeter s =
			match s with
			| Circle r -> 2 * Math.PI * r
			| Square sd -> sd * 4

Here is the moral equivalent in C#:

	 public abstract class Shape
	 {
	 	public abstract float Area();
	 	public abstract float Perimeter();
	 }
     
	 public sealed class Circle
	 {
	 	readonly float r;
	 	
	 	public Circle(float r)
	 	{
	 		this.r = r;
	 	}
	 	
	 	public override float Perimeter()
	 	{
	 		return Math.PI * 2 * r;
	 	}
	 	
	 	public override float Area()
	 	{
	 		return Math.PI * r * r;
	 	}
	 }
     
	 public sealed class Square
	 {
	 	readonly float side;
	 	
	 	public Circle(float side)
	 	{
	 		this.side = side;
	 	}
	 	
	 	public override float Perimeter()
	 	{
	 		return 4 * side;
	 	}
	 	
	 	public override float Area()
	 	{
	 		return side * side;
	 	}
	 }

A couple of things to note:

* The C# code needs 5 times as many line as the F# code (adding a new shape to F# will require about 3 lines, but the corresponding C# class definition will be at least 15 lines).

* The F# code is idiomatic, but hardly any C# programmer seals classes or defines them as immutable by default, even though it is a good practice.

That said, there are some advantages that C# enjoys. Consider our example code: Even though C# requires more lines of code to define a derivative of Shape, at a certain point it will always be easier to add new classes to C# than the corresponding variant to F# (see "The Expression Problem" - on the other hand, adding new functions that apply to Shape will be easier in F# than adding the corresponding new methods in C#). Also, F# is supposed to be a hardcore statically-typed language, but there are some advanced concepts (e.g. type classes) that are easy to realize in C# yet not in F#.

CmonDev5• 12 years ago

I noticed you sealed the C# classes. What if you want to keep it extensible, which makes sense? How will that extensible pattern matching look then?

Also would be interesting to see how long would C#6 code be (twice as short?).

Apart from the sample, I also don't understand why F#'s naming patterns are not consistent with the rest of .NET (in terms of starting letter case). Feels alien.

Also how come this was considered a sane syntax for arrays?

[|1; 2; 3|]

instead of

[1, 2, 3]

Even Haskell's syntax is less alien.

AndrewDucker• 12 years ago

Yeah, it looks a lot cleaner - but if you make that code available as a library then other people can't add new shapes easily, or deal with shapes that have more than one length (e.g. a rectangle, which has two).

wwosik2• 12 years ago

Well, C# idiomatic would be rather

  public interface IShape 
  { 
      float Area { get; }
      float Perimeter { get; }
  }

  public Circle : IShape 
  {
      readonly float r ;

      public Circle(float r)
      {
         this.r = r;
      }
      
     public float Area { get { return Math.PI * r * r; } }
     public float Perimeter { get { return 2 * Math.PI * r; } }
  }

  public Square: IShape 
  {
      readonly float a ;

      public Square(float a)
      {
         this.r = r;
      }
      
     public float Area { get { return  a * a; } }
     public float Perimeter { get { return 4 * a; } }
  }

Also, with this one you can create new Shapes in another project. With F# solution there, you must have access to original code.

zer0nes• 12 years ago

This is a rather poor example. If you distribute the C# code above as a library, people can extend and introduce another shape, while they cannot do it easily with you F# code.

louthy6• 12 years ago

Your F# example can be more concise:

    type Shape =
        | Circle of float
        | Square of float

    let area = function 
        | Circle r -> Math.PI * r * r
        | Square sd -> sd * sd

    let perimeter = function 
        | Circle r -> 2.0 * Math.PI * r
        | Square sd -> sd * 4.0

marxama• 12 years ago

Another thing is that the F# example has equality semantics built in, whereas in the C# example, you'd have to override Equals (and GetHashCode), adding more lines still (for some tedious work that you shouldn't have to do).

enricosada2• 12 years ago

This post is about latest feature added to f# language (syntax cleanup, speed, etc)

why use a functional language? see http://fsharpforfunandprofit.com/posts/ten-reasons-not-to-us...

Why use f#? see http://fsharpforfunandprofit.com/why-use-fsharp/ (concise for programmers) or http://fpbridge.co.uk/why-fsharp.html (more high level)

more info about fsharp at http://fsharp.org/

my take:

#ecosystem - vibrant and friendly community - open source (long time ago, use pr, wrote by community) - cross plat (linux/mac/win/ios/android) - is .NET, same standard library as C# or VB.NET and virtual machine (CLR). Finally open source - use nuget components written for .net - third party component with commercial support

#language - fun to use - concise, i can easy write code without boilerplate - multi-paradigm (functional first, but can do oop like c#) - easy interop with c#, native - fast - help write correct code (no null reference => no null reference exception, pattern matching, - easy async, parallel, gpu - unit of measure (like 1<m/s> )

and a lot, read the links above for a better (and faster) summary

JackMorgan• 12 years ago

F# is a general purpose language. It can do anything Java/C# can do, only shorter and safer.

Here is an example of a simple language tool not in Java/C# that makes it easier to write, read, and is safer. http://deliberate-software.com/function-pattern-matching/

F# can also call anything written in .NET, so it's easy to start using it right away.

The biggest complaint people have is that it is a totally new language, and the parts that make it simpler and safer take effort to learn. In all honesty, several developers I know don't want to learn it, mostly because they only know C#, and do not believe the claims of speed and safety. They cannot imagine what could be different, so a day or two in, they just think of it as "syntax wankery", and never get past that point.

Really, the different syntax just makes it about a third the size of the equivalent C#. That alone is fine, and usually is the reason people prefer languages like Ruby/Python. But the real power comes from deeply understanding computation expressions, the LINQ equivalent, and F# data structures. Those three allow code that is much safer and easier to write, without sacrificing any functionality.

At my work, (Winforms app and an MVC4 web site) I use it anywhere I'd use C#.

fsloth• 12 years ago

Good explanations already, but I'll add my two cents. F# has:

* Rich language constructs that encourage pithy and correct code (e.g. arrays and lists are a language type rather than a library datastructure and the syntax facilitates implementing very readably and succintly common operations on them)

* The combination of algebraic data structures and pattern matching enables succinct implementation of solutions for lots of common programming problems. This was perhaps the biggest wow feature of the language when I learned to use it well.

* Functional languages tend to encourage immutability. F# works idiomatically with mutable data as well, thus being well suited for e.g. numerical code. I would call this letting us have the cake and eat it too.

* I don't think there are any specific downsides to F#. Some programs are better expressed in C# still but the .Net platform allows one to access those classes seamlessly from F# side.

IMHO, these are all wins. There's not much unnecessary language wankery in F#, it was developed as an industrial tool from day 1. so most features have some rationale behind them.

oddthink• 12 years ago

I'll try to give a pragmatic example. At work, we've got a lot of analytics code in C# for model-estimation, pricing, etc. I spend a lot of time tweaking models, running them, then extracting and analyzing the results. F# works very well as a scripting language for me, where otherwise I would be using something like IronPython.

The results-processing I could do from anything (R, python), but scripting the run (running N random samples of something, doing simple cross-validation, manually hacking a pseudo-hierarchical model, etc.) is much easier when I have direct access to the C# API.

Since the codebase is always-evolving, the type checks of F# (as opposed to IronPython) are useful when going back to an old script.

I also just enjoy using F#. I'd been hoping to learn a ML-family language for years and working at a F#-friendly shop has let me do that.

virtualwhys3• 12 years ago

This is pretty cool, in my day-to-day language, Scala, we cannot do the following:

    [('a',1);('b',2);('c',3)] |> List.map String

In F# 4.0 the compiler infers that String takes 2 arguments and extracts the tuple accordingly.

In Scala we're forced to manually extract the tuple when the recipient function takes more than a single argument.

    def plus(a: Int, b: Int) = a + b
    List((1,2),(3,4)) map plus // kaboom
    List((1,2),(3,4)).map{case(a,b)=> plus(a,b)} // ok

We'll see where the Microsoft OSS movement goes. If in the not too distant future we can seamlessly take advantage of, for example, Type Providers and LINQ-to-SQL/Objects on Linux, I'll certainly give F# a deeper look.

Side note: the next 3 to 4 years will be huge in computing, IMO. Microsoft stack is coming to Linux and OSX, Oracle is finally pushing forward Java and the JVM, and FP languages in general seem to be picking up steam in terms of adoption. Good times ahead for everyone ;-)

pjmlp2• 12 years ago

FP languages in general seem to be picking up steam in terms of adoption

I have been looking forward to this since I learned Caml Light at the university back in 1996. Same applies to LP.

It was been a long way.

porker• 12 years ago

Same applies to LP.

LP = Literate Programming?

masklinn• 12 years ago

In Scala we're forced to manually extract the tuple when the recipient function takes more than a single argument.

Is there no `uncurry :: (a -> b -> c) -> (a, b) -> c` in Scala?

    Prelude> let ap = flip map
    Prelude> [(1, 2), (3, 4)] `ap` (+)

    <interactive>:11:3:
        No instance for (Num t0) arising from the literal `1'
        The type variable `t0' is ambiguous
        Possible fix: add a type signature that fixes these type variable(s)
        Note: there are several potential instances:
          instance Num Double -- Defined in `GHC.Float'
          instance Num Float -- Defined in `GHC.Float'
          instance Integral a => Num (GHC.Real.Ratio a)
            -- Defined in `GHC.Real'
          ...plus three others
        In the expression: 1
        In the expression: (1, 2)
        In the first argument of `ap', namely `[(1, 2), (3, 4)]'

    Prelude> [(1, 2), (3, 4)] `ap` (uncurry (+))
    [3,7]

Or some sort of `apply` method aliasing an n-ary function to a 1-ary function taking an n-tuple?

edit: there's a Function.tupled method so something like this might work:

    List((1,2),(3,4)) map plus.tupled

ssmoot• 12 years ago

re: Your edit: Basically. Lift the method to a function first.

  def plus(a: Int, b: Int): Int = a + b
  List( (1,2), (3,4) ) map(plus _ tupled)

  > List(3, 7)

( I know there's already 4 or 5 answers... I just think mine's the prettiest. ;-) )

ArturSoler• 12 years ago

It's not as concise, but you could do

  List((1,2),(3,4)) map (plus _).tupled

virtualwhys3• 12 years ago

Nicely done ;-)

However, not so easy to grok without knowing how to lift methods to functions in Scala and then applying the swiss army method of functionN types, `tupled`, to the result.

The F# equivalent one understands without needing to know special features of the language, it's pretty clear what's happening.

Rizz• 12 years ago

And a another way to use tupled is:

    list map Function.tupled(plus)

Hereby additionally proving the old saying 'if you need help with a product don't say you need help because you'll get hit with RTFM, just say too bad you can't do X in product while it's easy to do in [competing product], and everyone will try to prove you wrong.'

virtualwhys3• 12 years ago

and everyone will try to prove you wrong

heh, how true, though more of an invitation; a strength/weakness of Scala is the fact that there's often more than one way to do the same thing (at least 3 ways have been shown with the current example). From what I've seen F# does not have this characteristic.

Anyway, ideally the Scala compiler would provide the same level of concision that for comprehensions do vis-a-vis flatMap/map boilerplate, thus reducing our example down to: `list map plus`, the bare essentials ;-)

Worth noting that the source for Function[0] indicates `Function.tupled` methods are slated for removal in future: "these functions are slotted for deprecation, but it is on hold pending superior type inference for tupling anonymous functions"

https://github.com/scala/scala/blob/v2.11.4/src/library/scal...

jbeja• 12 years ago

I can't wait for .NET to be ported to Linux to try this, it looks awesome.

steego• 12 years ago

Stay tuned: There are already a number of docker containers with F# on them using Mono. Because the F# compiler is open source, you can probably create your own container pretty easily based on the preview builds. https://github.com/crosbymichael/fsharp-docker

sklogic• 12 years ago

It works just fine on Mono. Use the current F# from git.

gnuvince• 12 years ago

Very cool. After my M.Sc. I'm going to need to find a job, and since OCaml jobs are pretty much inexistant in Montreal, F# is my backup plan.

genwin• 12 years ago

Good thinking to be considering the demand. Why not a remote job? Also consider the trend. There's a site that ranks language popularity on a periodic basis.

louthy6• 12 years ago

It's great to see the gradual improvements in F#. I think it's a brilliant language. I was initially not too sure, because, even though I've been coding C# for a long time, my first foray into the functional world was Haskell - which is a stunning language. But when it comes to plain old let's-get-things-done pragmatism, F# wins out imo.

FlyingSnake3• 12 years ago

F# is a wonderful language, albeit I'm still getting used to style.

Is anyone here using F# for real project? It would be great to see it in wild.

louthy6• 12 years ago

I'm using it on a number of proprietary projects. Check out [1] for a ton of 'in the wild' projects:

[1] https://github.com/fsprojects

DanielBMarkham2• 12 years ago

Bunch of folks are. I've used it for several. I think there have been a couple of AskHNs for this.

I'd show mine but you wouldn't see any code! My latest is http://newspaper23.com

I use F# to generate static pages. This allows me to completely decouple the back-end from the display. I don't have interactivity yet, but I really don't see a need to add a framework to get it. F# and mono allows me to shoot for brutal simplicity. I like that. Many times projects that might be huge monstrocities in other languages turn out to be just a few well-coded modules running as Unix-y microservices in F#.

People are starting to give F# a lot of love as a .NET language, then wondering "Where's the framework?" I'm coming around to the conclusion that it works best when there is no framework. Fun times ahead.

noblethrasher8• 12 years ago

People are starting to give F# a lot of love as a .NET language, then wondering "Where's the framework?" I'm coming around to the conclusion that it works best when there is no framework.

Yes, in F# and other ML-like languages you tend to use libraries more than frameworks.

(I'm the original poster, and I've been extolling the virtues of ML-style functional programming throughout this thread, but I still owe you an email explaining why I think OOP is ultimately better than FP)

jackfoxy2• 12 years ago

Tachyus uses F# almost exclusively. We have had great success with it. Just released 2.0 of our stack to production. After a week, still no issues. We use it for server-side web development in Azure, iOS app with Xamarin, and Raspberry Pi Linux. Fantastic integration with SQL Server throught the SqlClient Type Provider. It's great having one language across platforms.

FlyingSnake3• 12 years ago

How does Raspberry Pi fit into the whole picture? Is it used as an 'Internet of things' device to collect telemetry data?

cflyingdutchman• 12 years ago

Jet.com is using F# as their core language. (and hiring) http://techcrunch.com/2014/09/16/quidsi-co-founder-raises-an...

curveship• 12 years ago

I've used it for parts of two commercial projects (not counting side projects). One was a small parser -- C#'s parser options were uninspiring while FParsec (based on Haskell's Parsec) was great. The other was to simulate a client-server algorithm we were developing under different network situations. F#'s ability to express algorithms concisely was a real win there.

Side projects have mostly been stats/data based: using type providers to mash together different data sources, with visualization via FSharp.Charting.

MichaelGG2• 12 years ago

I use it in telecom (VoIP). At peak, we were doing 1 billion calls a day. All routing decisions, F#. All call records, F# (on Mono).

I've also used it in network indexing, processing 5TB of SIP signalling a day on a single server, then indexing and storing each packet for later searching. This is now used in the voice arm of a large public telco to provide troubleshooting.

F# is a joy to work with and every time I use C# it's annoying.

FlyingSnake3• 12 years ago

F# on Mono, that's great. Did you face any major roadblocks with Mono/F# in production?

sbrother• 12 years ago

I used it for an internal app that's getting used by several of the top global pharma companies to solve an optimization problem. I would choose F# again in heartbeat for that sort of project: its expressiveness let me implement the core algorithm in just a few hundred lines of fast, readable code, and its seamless interface with Microsoft-world allowed me to to embed it in a standard "Enterprise" stack (a C#/WPF desktop app as well as an ASP .NET webapp).

DanielBMarkham2• 12 years ago

Normalized collection modules is a big plus. It was always a pain having to cast something out of one thing and into another just to get some method that should have been there in the first place. Same goes for slicing.

Some good stuff, guys!

fallat2• 12 years ago

If I've already been learning Haskell, should I keep going or stop, drop everything and learn F#? I'd like someone with F# and Haskell experience to answer.

louthy6• 12 years ago

Depends on your requirements. I use F# day-to-day, but I think Haskell overall is a better language. There's some ugly aspects to F#, like its OO grammar, lack of typeclasses and seeming randomness to the casing (sometimes camelCase and sometimes PascalCase). These are all artefacts of it being a pragmatic tool in a toolset: its requirement to work with other .NET languages and frameworks (and Mono).

So for a bit of ugliness, and some loosening of the type-system shackles, you get a whole ton of stuff.

Haskell as I'm sure you're aware is much stricter and much harder to interoperate with. But much more refined as a language. Whilst you do get the "If it compiles it will probably work" thing with F#, it's nowhere near the level of Haskell. Haskell tends not to play as well with Windows, but again it depends what you're doing. I've had very few problems with Haskell on Windows by writing stand-alone services that talk to the rest of the world through RabbitMQ.

So if you're writing something that must absolutely be provably sound, doesn't need to talk to much else, then I'd go with Haskell. If you need lots of core Windows features it'd probably be best with F#.

I went from Haskell to F#, and I'm glad I learned Haskell first because it gave me a much stronger grounding in functional concepts. It's much easier to 'break the rules' in F#.

I hope that helps.

fallat2• 12 years ago

Yes, thank you for your explanation, it was great.

That is why I've started with Haskell too (6 months in now), because it teaches you the fundamentals about FP, and is strict about it (a good thing in my opinion).

That being said, I will continue to use Haskell. I know C# and I'm sure the jump won't be too difficult if I ever need it.

F# 4.0 Preview

Related Stories