The Accepted answer is **slightly wrong**. "just slightly".
F# is amazing and has amazing support for OO as well (being the .NET Objective CAML implementation originally). In fact it has an awesome interop with C# (even in the same solution).

[![https://dotnet.microsoft.com/en-us/][1]][1]

But as always, best way is to try for yourself!

```fsharp
//dotnet fsi --> starts F# interactive
//or open vscode and a .fsx file, install ionide, and start typing
#r "nuget: FSharp.Data" //will download your package
open FSharp.Data

//and you are good to use it
let add x y = 
   x + y

let r = add 1 2

type MyJson = JsonProvider<"""{ "test" : "me" }""">

let sample = MyJson.GetSample()

let me = sample.Test // string! typed, and is "me"

```

try do this in scala now :D 


The very big difference to understand when checking functional languages is understanding language families and history, and know why ML language was invented and why Milner won an ACM touring award for it.

[![https://courses.cs.washington.edu/courses/cse341/04wi/lectures/02-ml-intro.html][2]][2]


The Why is the **ML type system**. 
both F# and Scala are statically (strongly) typed languages, but the main differences are : 

 * **Scala has no ML type inference**, and never will, and has very sad curly braces like C languages used just for scoping.
 * F# **doesnt higher order kinds** (scala/haskell pp brag a lot a about it) also for a language design choice, the F# lang directive thought wasn't really needed in 99% of cases of real day to day programming and would confuse people (which indeed it does most of times)
 * F# uses curly braces for **CE (Computation expressions) giving curly braces a total new meaning and dignity**, for building monadic operations in the best expressive way ever. (see task, async, query, etc..)

Why is scala more popular?
 * JVM the big beast makes languages more popular by default, doenst mean it's better, but JVM world brags about popularity quite a lot (more than quality). [Luckilly Python is now the most popular language and Java is going down day by day..](https://www.tiobe.com/tiobe-index/)
 * [NET platform is an amazing](https://dotnet.microsoft.com/en-us/) runtime and people should get updated not talk about 20 years ago NET as Microsoft and open source DOTNET foundation did huuuuuge improvements on the area, so huge now it competes with GO and RUST and low level languages on performance in many many areas. cannot be said for JVM.

A note on package management:
* package management on JVM and nodejs is a mess and complicated...
* package management in NET works like a charm and is amazing, plus nuget is part of the dotnet tooling, not an "external thing" anymore, so dependencies are part of your .fsproj or a line in your script .fsx amazing.

ML was the first lisp-like statically typed programming language,
and OCAML also supported object orientation and imperative construct,
giving the most pragmatic approach to functional programming languages.

This lets you write "like python or javascript" and have strong typing like any strongly typed language.

Pros on F#: 
 * it's a NET6 language runs everywhere part of the NET6 platform
 * F# has scripting and a repl and can be used like python/nodejs/bash
 * F# has type providers and the |> pipe operator, making it awesome to work with collections and data
 * F# has computation expressions, a very beautiful and simple way to write custom "monadic operations" in F# (not an expert here)
 * F# 6 supports natively Task
 * F# runs on aspnetcore easilly with beautiful libraries such as Giraffe/Saturn/Falco
 * F# looks much closer to javascript and is much more readeable than scala
 * F# transpiles to javascript with Fable compiler
 * F# is awesome and the F# community is great
 * F# is based on many years of academic research and 25+ years of OCAML as F# is an ocaml implementation for .NET, making it one of the best functional languages available today
 * F# doesnt (yet) run on the JVM, but is both a .NET language and a node.js language 
 * F# has automatic type generalization and everything is curriable
 * F# is supported on the best IDEs of the world : VsCode, Rider, VisualStudio
 * F# is opensource 100% and since long time
 * F# influences many languages (like C# and Typescript) wheras scala not as much... infact most JVM people prefer kotlin to scala (wich is kind of a jvm C# with union types, still much more limited)
 * Scala just is dumber as it's OO-like, making it a half-haskellish-java, but not having the type inference of haskell which is it's real power and much closer to F#. 
 * Check Haskell code, and you'll see it's much closer to F#
 * Python code and F# code also are closer
 * Javascript code and F# code also are closer


Cons of F#
 * doesnt have curly braces for scoping (but has for CEs, no worries!)
 * doesnt have Higher order Kinds... Oh No! big drama moment? (btw has generic interfces..)
 * Many Scala pp which really tried F# do like F# more, but they can't adopt it on the JVM atm...

 


  [1]: https://i.sstatic.net/WIT0i.png
  [2]: https://i.sstatic.net/4fnWj.png