
Becoming an F# contributor - numo16
http://mrange.wordpress.com/2014/12/11/becoming-an-fsharp-contributor/
======
Ironballs
It's strange how appealing F# becomes once you realize you have the full power
of the Visual Studio debugger _and_ the .NET libraries. To someone who has
mostly worked with Haskell (w.r.t. functional languages), that sounds great.
Good debugging is absolutely essential - though with strongly typed functional
languages, it's not often that necessary. But it's _nice_.

Then again, it's a very liberal language, if the end of the spectrum is
Haskell. It allows side effects and mutable variables. While very convenient,
nothing forces you to use these though. There are immutable data structures
for everything. But it seems there are all the functional tools you'd want.

It's not Haskell, it's not pure and beautiful like it, but you still have
computational expressions, which allow you to implement monads;
metaprogramming, operator overloading, units of measure, and active patterns.

My only gripe is that the compiler doesn't translate functions that can return
_null_ to return an option value (i.e. Maybes), and null values in general!
Would make interfacing the .NET library much cleaner. Right now I have to do
something silly like this:

    
    
      let notNull a = if a <> null then Some a else None
    

So I have to pipe every function call that may return null to this function
when I'm in the Maybe monad, which is frankly a bit bothersome.

Still. Even being able to use the Maybe monad when working with .NET is
_really cool_.

~~~
pjmlp
> Then again, it's a very liberal language, if the end of the spectrum is
> Haskell. It allows side effects and mutable variables.

Like the majority of ML languages. Haskell is pretty special here, being the
descendant of Miranda.

Personally I think ML languages of OCaml branch are better for the general
programmer public, as the entry level is a lower.

~~~
moron4hire
How do you feel about having a different set of operators for integers and
reals? Like "+." versus "+".

~~~
enricosada
F# use the same + operator

    
    
      > 1.0;;
      val it : float = 1.0
    
      > 1;;
      val it : int = 1
    
      > 3.0 + 1.0;;
      val it : float = 4.0
    
      > 3 + 1;;
      val it : int = 4
    

or strings

    
    
      > "3" + "4";;
      val it : string = "34"
    

implicit conversion is not supported (good ihmo)

    
    
      > 3.0 + 1;;
    
      3.0 + 1;;
      ------^
    
      stdin(5,7): error FS0001: The type 'int' does not match the type 'float'

~~~
moron4hire
I'd be fine with that. The OCaml way just seems needlessly preachy.

------
jackfoxy
tl;dr

The F# language has been open source for 4 years and MS has accepted pull
requests to the compiler, core library, and tools for over 6 months (100+ PRs
going into F# v4.0). Now with Microsoft fully committed to open source and
cross-OS development with .NET Core, this is a very good time for hackers
interested in meta-programming to get in on the ground floor of F#, the only
functional language fully supported by .NET.

This article is a complete guide to hacking on the F# core, in this case an
end to end example of extending the core library, including setting up
standard unit tests. And mentions looking to F# Language Design User Voice,
[http://fslang.uservoice.com/](http://fslang.uservoice.com/) as the source for
extension inspiration. One thing mentioned in the article, that F# will
"likely" move from codeplex to Github, should read that the MS team is
committed to fully migrate to Github, they are just busy right now with v4.0
of the language.

------
guiomie
I'm still hesitating between learning Common Lisp or F# for my next web
service project. I work with C# in my day job, so F# seems like a no brainer,
but I'd like to get away from the CLR and there isn't much out there on
getting F# running with vnext on linux (digital ocean).

Any opinions?

As for the posted link, quite interesting, a similar one for C# would be cool.

~~~
Touche
Yeah I wouldn't spend time on F# on non-Windows until the community builds up
more. So you probably want to try either OCaml or, if you're up for a bigger
challenge, Haskell.

~~~
guiomie
This is actually my impression, that Mono isn't at the same level of
performance than the windows counter-part. I guess we can expect with .Net
Core to see improvements. But will the Mono runtime ever be as good as the CLR
? The CLR isn't open sourced. The whole open-sourcing happening in the .Net
world is quite interesting, but It is also confusing the hell out of me.

~~~
enricosada
TL;DR .net core = surgery of .NET Libraries for crossplat cleanup + RyuJIT
Virtual Machine (clr)

The clr will be open source (with new RyuJIT jit compiler), it's happening one
commit at time :D

open source CLR/full .NET = readonly sources MIT (and mono can import fixes to
BCL)

.NET Core = RyuJIT VM + .net Core BCL libraries + redesigned for modularity +
CrossPlat + Development on github

Mono will maybe merge with corefx

Open source components are: \- the .NET Framework Libraries (BCL of full .net)
\- NET Core Framework Libraries (BCL of new .net core) \- RyuJit VM

more info * Miguel de Icaza (MONO) post
[http://tirania.org/blog/archive/2014/Nov-12.html](http://tirania.org/blog/archive/2014/Nov-12.html)
* Microsoft post
[http://blogs.msdn.com/b/dotnet/archive/2014/12/04/introducin...](http://blogs.msdn.com/b/dotnet/archive/2014/12/04/introducing-
net-core.aspx)

