For instance, first thing I did was I used suave.io to expose a webservice for a digital IO module ( http://www.mccdaq.com/ ) and it amounted to around 50 ish lines of code. Runs flawlessly.
The F# community is pretty awesome as well with a good ratio between experts and people learning the language.
Or there is also a new attempt (https://github.com/dustinmoris/AspNetCore.Lambda) to use api similar to suave, more integrated with asp.net core itself (security/auth/etc).
There are zero Elixir jobs on my part of the planet.
Whereas F# is on my PC thanks to a full VS install done by IT, and I can at least use it instead of Powershell.
Source: Have spent a lot of time with F#, including writing Type Providers (which would not solve the problem).
Anyway, I don't think to be "attractive" it needs to match Phoenix/elixir macros. Nice frameworks can be made in fsharp, and its type system and tooling blows type specs and dialyzer out of the water.
Really it needs to be:
* (x-platform && easy to use) which is why I'm so keen for the official 4.1 fsharp release. The ecosystem around fsharp and dotnet core needs all the sharp edges ground down.
* Smooth OOTB experience
* Community momentum
* Excellent plug/middleware solution(building on top of asp.net core might be the right approach)
Then just let fsharp shine on its own merits.
VS Code has good integration, check out the Ionide plugin.
For a language introduction, this wikibook is quite ok: https://en.wikibooks.org/wiki/F_Sharp_Programming
github.com/Frege and eta-lang.org may be tried out
Counting on github returns about 10k for each F# and Ocaml, about 60k for Haskell, and 100k for Scala, but about < 200 for Frege.
That then should be the actual answer to OP's question
There is actually a really interesting (to me) discussion going on about where Scala sits on the Intersection of Java,ML & Haskell going on in the r/Scala subreddit at the moment:
I was/am expecting Haskell to be broadly similar to ML - what's the main way the two languages differ?
edit: never mind, from the reddit discussion you linked:
> while these languages are undoubtedly strongly typed, they are not referentially transparent by default, and actually embrace some levels of imperative programming.
Good read, thanks!
(first paragraphs and "influenced by")
But Scala indeed is very similar to (1) OCaml and then (2) ML, and last, (3) Haskell in terms of type inference, syntax, and many other FP concepts .
(Short answer: No, because it has [to support] subtypes.)
Another good Source: http://blog.ploeh.dk/
And lots of good tutorial/ideas
If you want to get an intro to the language w/o installing anything, give Jupyter notebooks a try - F# intro/tutorial:
(you can just browse it, or sign in to clone & run & edit & ... )
With Silverlight installed, you can try it in the browser. They really need to update this to work with just a modern browser!
PS C:\foo> dotnet --version
1.0.0-rc4-004771 <- vs 2017 RC4
PS C:\foo> dotnet new mvc -lang F#
Pretty certain this is 4.1 and already out.
Articles have been around for a while
I'm looking forward to the release and the subsequent smoothing of the .net core fhsarp ecosystem.
Or use VS2017-rc, to use f# 4.1 with .NET framework
Or use .NET Core sdk and .net core
https://github.com/dotnet/netcorecli-fsc/wiki/.NET-Core-SDK-... the default templates use new f# 4.1
Ionide in vscode support .net core (both project.json and msbuild sdks), atm there is a temporary issues with rc4, but feel free to use a previous sdk (are really similar, no need to stay bleeding edge, and will be fixing sooner than later).
See wiki https://github.com/dotnet/netcorecli-fsc/wiki for more info about f# and .net core, or new sdk (all version, with how-to and workaround if needed)
Expect full support around .NET Core 2.0 time.
* Seemless x-platform with dotnet core
* ionide working with dotnet core(and ideally on par with at least xamarin fsharp support)