What's the best language to learn between OCaml, F#, Scala, and Rust...

scala.
It is used for big data and you can make big money my dood.

Haskell

every other paradigm is even worse though
>C
>Java
>Python

>OCaml
>F#
>Scala
>Rust
>Haskell

Jesus fucking Christ, so many meme languages. Let me give a list of languages that are actually useful:

C, C++, or Assembly for x86 or mainframes

MATlab is excusable if you are an engineer.

Attached: disgusting rostie.gif (500x398, 1.91M)

>C, C++, or Assembly for x86 or mainframes
>muh low level meme

he's looking at functional, high level languages and you recommend Assembly? F#/OCaml is the way I would go.

Attached: 1493849080148.png (490x490, 376K)

Rust isn't really high level.

Haskell > F# > OCaml > Scala
Retard

he's not wrong, F# is microsoft's take on OCaml just as C# is their take on Java

Scala programmer here. Haskell is way easier to deal with than scala when you really get going.

F# is MS copy of OCaml which is CLR's equivalent of JVM's Scala.

>Rust is higher level than C or C++

Attached: (you).jpg (1170x742, 94K)

Is there a language with Lisp syntax but with static typing?

>I'm not smart enough to understand an actual type system.
We all realize it's not your fault, user. No one blames you.

Attached: tsukasa_kagami.jpg (625x750, 74K)

There's a statically typed (and a gradually typed) dialect of Racket. I haven't used it, but it might fit your needs.

>functional
>high level language
lmao'ing@urlife

Yeah, if want to make a program that runs like shit, use Python for your prototyping. But recommending jokes of a language like F#? Seriously?

Classes manage their own state, which changes multiple times during operation. This literally means you can errors that are near impossible to reproduce. It's SHIT.

Most mainstream-ish FP languages tend to have a simpler type system than Java's though. Almost all of the features used are just applying parametric polymorphism with very simple bounds in more general ways.

The main reason why the FP people talk about types more is because most type systems with subtyping of concrete types are difficult enough to understand that most users of the languages that have them simply don't properly about them at all.

Did you even read the OP? he's only stated he wants trying to lean one of these languages and python was not among them neither was C/C++ or assembly like you recommended. We don't even know what he's trying to implement, so you can stop sperging out sweetie

F# is a much better language than Python is, even its OOP model for C# interop is better.

It's a pragmatic language which can do a GUI hello world in a single line. If it had more (ideally cross-platform) support, I definitely would use it over Python.

The depends on what you mean by mainstreamish and typical features, and there is some type complexity in Java, but I basically don't take your premise.

First, Java allows type coercion and isn't type safe. The type system can be circumvented entirely.

Java has a classical OOP paradigm. This gives you something like sum types and subtyping, although there's no way to exhaustively match on patterns to eliminate the sum. Java also doesn't have a second-order module system like ML or a system of typeclasses like Haskell. Its generics confer a lot more than just parametric polymorphism (in the system F vein, which is well-understood) and are Turing-complete. From one point of view, this gives a lot of power, but they're also, for instance, unsound:
io.livecode.ch/learn/namin/unsound

Finally, Scala, Haskell, Idris, Coq, etc. all have dependent types, which are way more complex than anything in Java.

One other thing: Java 8+ is a "functional" language (or at least can be used as such) since it has function types (lambdas). It's not a particularly great one, but user I was replying to seemed unaware of this.

The big differentiating factor is that there isn't a neutral choice that doesn't use either CLR or JVM in the Java/C# dichotomy, whereas OCaml is precisely that in the Scala/F# one.