.NET Fiddle adds F#

http://dotnetfiddle.net/AT4DxW

by refactormonkey • 13 years ago

105 71 13 years ago

dotnetfiddle.net

agentultra• 13 years ago

I found F# to be rather neat. This is a great way to see for yourself.

JeremyMorgan2• 13 years ago

I've done very little but it seems really concise. I like that.

One place some predict it will emerge is in the Web API arena, and I could totally see that happening.

dyml• 13 years ago

Why? What makes it better than C# in web Web API area? (honest question)

ponzao4• 13 years ago

Outside of web development any ideas what I could use it for (I am on Linux so it should run on Mono)? I've done quite a lot of web development on the JVM with Clojure, Scala and Java and would like to try to do something totally different with F#.

zequel• 13 years ago

Can anyone comment how F# compares to other functional languages? Just curious.

the1• 13 years ago

learn haskell because it's harder.

throwaway3444• 13 years ago

F# is very un-functional in many ways. Immutable variables are the default but mutable variables are made with just the "mutable" keyword. There are also lots of imperative control structures, like while, and for. Those two combined means that imperative algorithims typically have two distinct translations into F#.

First you can translate it literally, where F# looks like a slightly more verbose version of Python. Second you can exploit all the functional features of F#, and using immutable variables, recursion and pattern matching.

F# also has extensive support for OOP, and uses it where OCaml-ers might use modules or functors.

In that way, F# can be a sort-of stepping stone between the imperative, OOP C# to more functional features of F#.

UK-AL• 13 years ago

The idea is that it is a functional first programming language, but allows you to use imperative or OO styles when the problem suits it.

mmavnn• 13 years ago

Un-functional might be a bit misleading for an ML-based, default immutable language. Impure might be slightly more accurate.

Having seen F# written by C# coders who've just learnt the syntax, and haskell programmers who are having to work in a .net environment, I'd say F# does a fairly good job of supporting both. It does make some trade offs to allow easy interop with the rest of the .net world (it's type system is much less powerful than Haskell, Scala or (especially) Idris) but depending on your environment that can be out weighed by the massive scale of the .net ecosystem, easy interop with your existing .net code and very, very good tooling.

bunderbunder7• 13 years ago

I'm not sure I'd say un-functional, just multiparadigm. But having at least some support for imperative programming is the norm in functional languages - ML does it, most LISP dialects do it, etc. Even Scheme, originally notable for its lack of loops, still has set! and idioms for combining it with closures and tail recursion to produce constructs that behave like loops.

And impure, of course. It's definitely an impure language. Personally, though, I'm not at all fond of conflating the terms "pure" and "functional". It's a terrible retcon that has more to do with the Haskell proselytism than with the development and history of functional programming or how its community has self-identified over the years. Note that the seminal book's title is "Purely Functional Data Structures", not something that's only three words long.

tel• 13 years ago

I haven't used F# much but my impression is that it came from an OCaml background and thus perhaps sits halfway between C# and OCaml. Many of the useful type system features of Haskell are missing, but the module system of OCaml has been developed to be closer to the object system of C#.

refactormonkey4• 13 years ago

Small interruption. Looks like scaling to 2 servers on Azure to handle extra traffic crashed the original one.

el_tone• 13 years ago

Azure will reset your VMs when you update their configuration. Normally this involves a rolling reset but as you only have one instance this was not possible.

refactormonkey4• 13 years ago

Thanks for the info. I thought changing Scale would keep original server and just add new ones. But I guess it is a bit more intrusive.

refactormonkey4• 13 years ago

Should be back up now. Mostly... If you get page not found, new DNS record didn't propogate yet. You can still use dotnetfiddle-prod.cloudapp.net or 191.234.40.

Sorry for interruption. Lesson learned.

physicslover• 13 years ago

I would like to see an interactive loop to fsi. Seems like you could use websockets for this.

refactormonkey4• 13 years ago

Yeah, we are looking into it. Interactive provides great information to see what is really going on.

AltGr• 13 years ago

F#'s big brother, OCaml, has this: http://try.ocamlpro.com The best part is that since OCaml can compile to JS, it's completely offline !

latkin3• 13 years ago

Another option you might want to look at is http://www.tryfsharp.org/Create Runs code locally via Silverlight.

JeremyMorgan2• 13 years ago

I'm getting my fizz buzz on.

virtualwhys5• 13 years ago

Cool to "see" F# in action.

Like the union types, but not so much the list operations; seems more natural to:

[1;2;3;4] filter isEven sum

vs.

List.filter isEven [1;2;3;4] |> List.sum

in Scala it's: List(1,2,3,4) filter isEven sum

Of course I'm not familiar with F# so don't know all of the WIN within (Type Providers, for example, are very impressive, would love to see that on the Scala side of the fence one day).

throwaway3444• 13 years ago

In F#, most pipelined operations are expressed using the pipeline operator all the way.

[1; 2; 3; 4] |> List.filter isEven |> List.sum

That way you maintain the same operator order as you do in Scala, while maintaining some consistency with currying.

In addition, you can add other functions really simply while still maintaining the order.

[1; 2; 3; 4] |> List.filter isEven |> List.sum |> printfn "%i"

virtualwhys5• 13 years ago

Interesting, in Scala you do:

list filter isEven foreach println

Which is, IMO, quite elegant, but then again I'm used to Scala and not yet at all familiar with F# and the reasoning behind the syntax.

latkin3• 13 years ago

The most common way to format code like that in F# would be something like let evenSum = [1;2;3;4] |> List.filter isEven |> List.Sum

Using |> is a win for two reasons - code flows more naturally, and the type inferencing works better. e.g. List.Map (fun d -> d.Hour) [DateTime.Now] does not compile, but [DateTime.Now] |> List.map (fun d -> d.Hour) does.

thinkpad204• 13 years ago

That seems odd. It seems that `arg |> func` would simply be sugar for `func arg` (or a function that accomplished this). Why are they not equivalent?

thinkpad204• 13 years ago

I guess it's all a matter of what you're used to, because coming from ML-family languages like F# and Haskell, the first thing you wrote doesn't really make any sense to me. In the ML family like F# is, you put the function (e.g. "filter isEven") before the argument ([1;2;3;4]).

virtualwhys5• 13 years ago

Right, which is why ML languages are a bit baffling for me, the ordering seems totally off ;-)

Just getting started with Haskell and am having several, shall we say, WTF moments.

bunderbunder7• 13 years ago

I've got little experience with Scala, but judging from your sample it looks like what's happening is that Scala follows more Java-y idioms for how code is structured.

So in

  List(1,2,3,4) filter isEven sum

it looks like filter and sum are instance methods on the List class, and I'm guessing isEven is a predicate that's being passed as an argument to the filter method.

F# leans closer to its functional roots in this respect, so it's more idiomatic to keep object-oriented constructs at arm's reach in most your code. The language has full support for OOP, it's just that you're not expected to trot it out except when you're writing public interfaces that are meant to be consumed by code that might be written in C# or VB.NET. So the List class mostly sticks to static methods in its public interface because that approach fits better with traditional functional idioms.

That gets you as far as something like this:

  List.sum (List.filter isEven [1;2;3;4])

The next step is the "pipeline" operator, which is defined as

  let inline (|>) x f = f x

So it's just letting you swap a function and its argument, which facilitates reorganizing the code so that the functions are listed in the order in which they execute. That's what gets you to the example you give - or better yet:

  [1;2;3;4]
  |> List.filter isEven
  |> List.sum

which I think captures some of the natural expression that you were talking about while still sticking with functional idioms instead of object-oriented ones.

jdmichal3• 13 years ago

So the List class mostly sticks to static methods in its public interface because that approach fits better with traditional functional idioms.

And also fits perfectly with the C# and VB.NET extension method syntactic sugar, which was used extensively for LINQ. They're really just static methods in the .NET VM and bytecode.

frowaway0018• 13 years ago

F# leans closer to its functional roots in this respect, so it's more idiomatic to keep object-oriented constructs at arm's reach in most your code. The language has full support for OOP, it's just that you're not expected to trot it out except when you're writing public interfaces that are meant to be consumed by code that might be written in C# or VB.NET.

Wouldn't it have been better to keep such things out of the language instead of having a considerable amount of complexity in the language for stuff people are not even supposed to be doing in the first place?

Paradigma11• 13 years ago

The reason is that f# using the .net type system has no higher kinded generics. So you can abstract over t in List<t> but not over u in u<t>.

balsam2• 13 years ago

Anybody managed to install F# on Ubuntu? There are recommended steps [0] but they've never worked for me even on a new 13.04 (& later) image on DigitalOcean.

[0] http://fsharp.org/use/linux/

profquail2• 13 years ago

I use F# on Windows and FreeBSD, but I've used it on Ubuntu a few times before for testing. Here's how I did installed it:

  git clone git://github.com/mono/mono.git
  cd mono
  autogen.sh
  sudo make install clean
  cd ..
  git clone git://github.com/fsharp/fsharp.git
  cd fsharp
  autogen.sh
  sudo make install clean

It takes a while to build Mono from scratch, but this way has always worked for me.

balsam2• 13 years ago

Your steps are almost the same as the one I linked. But I tried them, just in case. And it still does not build. The fsharp build fails with some error about casting types. Do you have version details?

.NET Fiddle adds F#

Related Stories