When comparing F# vs Pony, the Slant community recommends F# for most people. In the question“What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?” F# is ranked 7th while Pony is ranked 22nd. The most important reason people chose F# is:
F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write.
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Concise syntax
F#'s syntax tends to be terse while remaining very readable and easy to understand without being a chore to write.
Pro Easier transition from other paradigms
Since F# is not a purely functional language, it lends itself to being more easily picked up by programmers that have experience with other paradigms.
Pro .NET Interoperability
Since F# runs on the Common Language Runtime or CLR, it has access to the entire .NET Framework, as well as libraries written in other .NET languages such as C#, VB.NET, and C++/CLI.
Pro Multiplatform, it runs on .Net Core
Forget Xamarin and Mono. F# now runs on the multiplatform .Net Core!
Pro You can run F# in the browser
Thanks to a project like Fable, you can write and run your client app in F# and run it over JavaScript. It allows you to share code between your server and client.
Pro Natively supported by Visual Studio
This is a .Net language natively supported by Visual Studio. Though it is not as tooled up as C# the support is still substantial. In particular, C# deployment scenarios can be enabled for it with small C# wrapper projects. Integration with Visual Studio provides: IntelliSense, debugging, projects an other features.
Pro Fall into the pit of success
F# directs you into a workflow where the right way is the path of least resistance.
Coming from a C# background, its restrictions might feel arbitrary at first (e.g., what do you mean my code has to be in dependency order!? Arbitrary alphabetical or bust!), but you'll soon realize that your code is cohesive, concise and consistent in a way that it never was before - and you can compile and run with confidence!
Pro F# is supported by Xamarin
Thanks to Xamarin, F# is a functional language that you can use to build for iOS, Android and Windows.
Pro Concurrency model based on actors
The unique type system allows the compiler to automatically schedule actors on threads, giving you reliable concurrency for free.
Pro Reliable
Because of its capabilities secure type system, provided you don't use the C FFI, references will never be stale, race conditions are effectively impossible, deadlocks don't happen because locks and mutexes are never needed, and processes never crash because all exceptions must be handled. (Barring compiler bugs or external memory corruption, of course.) Pony programs can still lock up due to infinite loops, like any Turing-complete language.
Pro High performance
Compiles to native code, and features an intelligent garbage collector that takes advantage of the actor architecture to get essentially free garbage collection.
Pro Trivially simple C FFI
Calling low-level C functions is as simple as use "lib:clibrary"
and @c_function_name[return_type](parameter:type)
. Linking C to Pony libraries is just as easy, as the Pony compiler will generate appropriate header files.
Cons
Con Has no ad-hoc polymorphism (á la Type Classes)
You have generics, you have interfaces, you have inheritance, you have a lot of things at your disposal but you don't have Type Clases. They can be emulated using some clever constructs but there's nothing like having the real thing.
Con Infested with OOP
Still relying on .NET OOP libraries.
Con All exceptions must be caught
The compiler enforces this, so code is littered with try
s.
Con Limited documentation
As Pony is such a new language, documentation is relatively light, and tutorials are few and far-between.
Con Few libraries
Con Garbage collector can't run until you yield
A long-running behavior can leak memory because the garbage collector has no chance to run.
Con Limited tooling
There's no IDE. Debuggers are fairly basic. Pony is too young to have much of an ecosystem.
Con Divide by zero is allowed
And instead of some sensible result like NaN or Inf, the answer is zero! Most languages would just raise an exception (and Pony used to do this), but since the compiler enforces the rule that "all exceptions must be caught" the proliferation of try
s was determined to be too burdensome on the programmer. This makes the whole design of the exception system questionable.
Con Unstable API
Pony is not ready for production. It has yet to release version 1.0, and there are frequent breaking changes.
Con Difficult learning curve
The type system uses a capabilities-oriented approach to reference semantics, which can be difficult to wrap your head around at first. The lack of more common object-oriented features and the preference for simplicity over familiarity can make it difficult for new users to model their program design.