It is known that all functional languages share some basic properties like using functions as basic building block for programs with all the consequences like using recursion in
Fundamental properties?
The first is beautiful, the second is an ugly side-effect of the former (pun intended).
The real-world compensation for lack-of-state is what I find to be the biggest differentiator between functional languages.
Those few things give lots of freebies. Most of the time, languages handle memoization.
I like Chris Conway's answer that states some important axes that help classify different functional languages.
In terms of features of specific languages, I'll pick F# to call out some features not found in many other FPLs:
In terms of general classification, F# is
Your question is phrased in a way with clear bias against some extra-language pragmatics (e.g. what runtime does it integrate with), but you also ask what "influences the way you develop", and these things do influence that:
(I think that trying to separate a language from its runtime and tooling is a mostly academic exercise.)
So there's a description of lot of distinctive features of one particular language of which I am a fan. I hope others might post similar answers that call out distinctive features of other individual languages.
Off the top of my head:
Only the first two items are really unique to functional languages (i.e., almost all imperative languages are eager and impure).
Non-strict vs strict evaluation.
Static vs dynamic typing.
Structural vs nominal static typing. OCaml is the only language I can think of with structural typing (in both objects and polymorphic variants), which closes the gap with dynamic typing by removing the need to define many types (e.g. variant types).
Hindley-Milner derivatives vs other static type inference algorithms. SML, OCaml, Haskell and F# use type inference algorithms based upon Hindley-Milner whereas Scala has only local type inference (like C# 3) and requires many more annotations to compile. (Haskell code is often full of type annotations at the function level but most are unnecessary and are added for documentation and to help the compiler in the presence of errors).
Pattern matching vs manual deconstruction. SML, OCaml, F#, Haskell, Mathematica and Scheme automate the deconstruction of values.
Closed sum types vs only open sum types. SML, OCaml, F# and Haskell allow closed/sealed algebraic types to be defined to strengthen static typing by conveying more specific constraints implicitly. OCaml and F# also allow open sum types whereas SML does not and Haskell requires an elaborate workaround (described by Oleg Kiselyov).
Bounded-time patterns. Pattern matching is very fast in SML and (vanilla) OCaml but has unknown performance in F# due to active patterns and even unknown asymptotic complexity in Mathematica.
On-the-fly compilation to native code. F#, Lisp and Scheme allow code to be generated, compiled and executed efficiently at run-time.
Macros. OCaml, Mathematica, Lisp and Scheme are extensible languages.
Standardized vs proprietary. SML, Haskell 2010, Common Lisp and Scheme are standardized languages whereas OCaml, Erlang, F# and Mathematica are proprietary.
Functional Programming is a style, not a language construct
Most functional languages have some common principles:
But the most important principle is that they usually force you to write in a functional style. You can program in a functional style in most any language. C# could be considered "functional" if you write code like that, as could any other language.
There are many differences but only two differences I'd categorize as fundamental in that they make a big difference to your development: