If anyone is interested in this topic, please watch this and you will learn how ruby can be used in a functional way, what the roots of the functional programming are, why ruby is not functional language even if it is capable to program functional: youtube.com/watch?v=5ZjwEPupybw
– maddin2codeSep 24 '14 at 20:22

12 Answers
12

One of the most critical aspects to be able to program in a functional style is if the language supports higher order functions... which Ruby does.

That said, it's easy to program in Ruby in a non-functional style as well. Another key aspect of functional style is to not have state, and have real mathematical functions that always return the same value for a given set of inputs. This can be done in Ruby, but it is not enforced in the language like something more strictly functional like Haskell.

So, yeah, it supports functional style, but it also will let you program in a non-functional style as well.

Using this criteria, would you say Smalltalk is functional because it has blocks?
– OscarRyzJul 30 '10 at 21:36

Good answer but one nitpick - higher order functions aren't strictly required for a functional style. e.g. You can achieve functional style in Java (which doesn't have first class/higher order functions) by defining function objects and composing them to get the same effect as a higher order function.
– mikeraJun 29 '11 at 17:09

2

Just, want to state that @peter asked Is ruby a functional language? and in a straight answer is a simple no. Ruby is a Object Oriented language with some functional features.
– Elias PerezAug 5 '16 at 16:15

Whether a language is or is not a functional language is unimportant. Functional Programming is a thesis, best explained by Philip Wadler (The Essence of Functional Programming) and John Hughes (Why Functional Programming Matters).

A meaningful question is, 'How amenable is Ruby to achieving the thesis of functional programming?' The answer is 'very poorly'.

The slides you gave didn't mention why Ruby is "very poorly amenable to achieving the thesis of FP." Why is C# more amenable than Java (OK, easier anonymous functions?)? Is it because you can have global variables in Ruby?
– kizzx2Sep 19 '10 at 7:38

7

No the slides don't go into this detail, since this is quite an extensive topic. At the risk of excessive simplification, for example, Ruby enforces an evaluation model (call-by-value) that ensures non-compositionality of programs. The implications of this can easily be under-estimated. Ruby is also married to the idea that a program is a sequence of effects. That is to say, Ruby goes out of its way to make it difficult/intractible to use any other computational model. I hope this short comment helps.
– Tony MorrisSep 27 '10 at 1:04

2

+1 for pointing out the ambiguity in classifying languages as functional. Hell, I've written functional C!
– EliOct 4 '10 at 23:31

Ruby does support higher-level functions (see Array#map, inject, & select), but it is still an imperative, Object-Oriented language.

One of the key characteristics of a functional language it that it avoids mutable state. Functional languages do not have the concept of a variable as you would have in Ruby, C, Java, or any other imperative language.

Another key characteristic of a functional language is that it focuses on defining a program in terms of "what", rather than "how". When programming in an OO language, we write classes & methods to hide the implementation (the "how") from the "what" (the class/method name), but in the end these methods are still written using a sequence of statements. In a functional language, you do not specify a sequence of execution, even at the lowest level.

I agree with most of your statement, however, I disagree on "Functional Languages do not have the concept of variables as you would have in Java etc." In haskell, you can use variables in pure functions, you can even assign a function to a variable, the biggest difference is that once a variable is assigned it can not be modified afterwards.
– HHCAug 2 '13 at 2:06

5

HHC, by definition, a variable is a value that can change. What you are speaking of is values.
– Scala NewbJun 6 '14 at 21:23

I submit that supporting, or having the ability to program in a language in a functional style does not a functional language make.

I can even write Java code in a functional style if I want to hurt my collegues, and myself a few months weeks on.

Having a functional language is not only about what you can do, such as higher-order functions, first-class functions and currying. It is also about what you cannot do, like side-effects in pure functions.

This is important because it is a big part of the reason why functional programs are, or functional code in generel is, easier to reason about. And when code is easier to reason about, bugs become shallower and float to the conceptual surface where they can be fixed, which in turn gives less buggy code.

Ruby is object-oriented at its core, so even though it has reasonably good support for a functional style, it is not itself a functional language.

That's my non-scientific opinion anyway.

Edit:
In retrospect and with consideration for the fine comments I have recieved to this answer thus far, I think the object-oriented versus functional comparison is one of apples and oranges.

The real differentiator is that of being imparative in execution, or not. Functional languages have the expression as their primary linguistic construct and the order of execution is often undefined or defined as being lazy. Strict execution is possible but only used when needed. In an imparative language, strict execution is the default and while lazy execution is possible, it is often kludgy to do and can have unpredictable results in many edge cases.

I think you can make a much better case for calling Ruby functional than Java.... no, Ruby is not strictly functional, but it is pretty easy to use a functional style in it... and a non-functional style colleague can easily change it back to non-functional
– Mike StoneOct 1 '08 at 22:11

1

Yes, Mike, if you want to code in a functional style, then Ruby is a huge improvement over Java. I was only using Java to exaggerate and hammer the point home.
– Chris VestOct 1 '08 at 22:20

Many people consider Lisp and Scheme functional languages, largely due to the pervasive use of anonymous functions. And yet, they lack guaranteed pure functions. Limiting the term to languages that support pure functions seems far too restrictive.
– skymtOct 2 '08 at 1:11

Good points. I have revised my answer in accord.
– Chris VestOct 2 '08 at 10:00

Ruby will have to meet the following requirements in order to be "TRUELY" functional.

Immutable values: once a “variable” is set, it cannot be changed. In Ruby, this means you effectively have to treat variables like constants. The is not fully supported in the language, you will have to freeze each variable manually.

No side-effects: when passed a given value, a function must always return the same result. This goes hand in hand with having immutable values; a function can never take a value and change it, as this would be causing a side-effect that is tangential to returning a result.

Higher-order functions: these are functions that allow functions as arguments, or use functions as the return value. This is, arguably, one of the most critical features of any functional language.

Currying: enabled by higher-order functions, currying is transforming a function that takes multiple arguments into a function that takes one argument. This goes hand in hand with partial function application, which is transforming a multi-argument function into a function that takes less arguments then it did originally.

Recursion: looping by calling a function from within itself. When you don’t have access to mutable data, recursion is used to build up and chain data construction. This is because looping is not a functional concept, as it requires variables to be passed around to store the state of the loop at a given time.

Lazy-evaluation, or delayed-evaluation: delaying processing of values until the moment when it is actually needed. If, as an example, you have some code that generated list of Fibonacci numbers with lazy-evaluation enabled, this would not actually be processed and calculated until one of the values in the result was required by another function, such as puts.

Proposal (Just a thought)
I would be of great to have some kind of definition to have a mode directive to declare files with functional paradigm, example

You are welcome. I would like to invite you to read about functional languages. Lisp being the grandparent of all functional langue, ML(CAML) and Erlang/Elixir. It really changes your perspective of things. I'm bar far no expert but a constant student of computer science enjoy reading and learning new stuff.
– Elias PerezAug 5 '16 at 16:13

It depends on your definition of a “functional language”. Personally, I think the term is itself quite problematic when used as an absolute. The are more aspects to being a “functional language” than mere language features and most depend on where you're looking from. For instance, the culture surrounding the language is quite important in this regard. Does it encourage a functional style? What about the available libraries? Do they encourage you to use them in a functional way?

Most people would call Scheme a functional language, for example. But what about Common Lisp? Apart from the multiple-/single-namespace issue and guaranteed tail-call elimination (which some CL implementations support as well, depending on the compiler settings), there isn't much that makes Scheme as a language more suited to functional programming than Common Lisp, and still, most Lispers wouldn't call CL a functional language. Why? Because the culture surrounding it heavily depends on CL's imperative features (like the LOOP macro, for example, which most Schemers would probably frown upon).

On the other hand, a C programmer may well consider CL a functional language. Most code written in any Lisp dialect is certainly much more functional in style than your usual block of C code, after all. Likewise, Scheme is very much an imperative language as compared to Haskell. Therefore, I don't think there can ever be a definite yes/no answer. Whether to call a language functional or not heavily depends on your viewpoint.

Ruby isn't really much of a multi-paradigm language either, I think. Multi-paradigm tends to be used by people wanting to label their favorite language as something which is useful in many different areas.

I'd describe Ruby is an object-oriented scripting language. Yes, functions are first-class objects (sort of), but that doesn't really make it a functional language. IMO, I might add.

The type of language is defined by the programming styles it supports; that, in turn, is decided by the features it has. First-class and anonymous functions = minimal functional programming. Ruby supports OO programming but doesn't require it: you never need to define a class. Hence, multi-paradigm.
– skymtOct 1 '08 at 21:35

Recursion is common in functional programming. Almost any language does support recursion, but recursive algorithms are often ineffective if there is no tail call optimization (TCO).

Functional programming languages are capable of optimizing tail recursion and can execute such code in constant space. Some Ruby implementations do optimize tail recursion, the other don't, but in general Ruby implementations are not required to do TCO. See Does Ruby perform Tail Call Optimization?

So, if you write some Ruby functional style and rely on TCO of some particular implementation, your code may be very ineffective in another Ruby interpreter. I think this is why Ruby is not a functional language (neither is Python).

TCO is interesting, because it essentially changes the behaviour of the program. In certain cases, this isn't visible to the program, but in other cases, it is, e.g. exception backtraces. Therefore, it isn't always an appropriate optimisation.
– ioquatixMar 4 '14 at 1:16

Strictly speaking, it doesn't make sense to describe a language as "functional"; most languages are capable of functional programming. Even C++ is.

Functional style is more or less a subset of imperative language features, supported with syntactic sugar and some compiler optimizations like immutability and tail-recursion flattening,

The latter arguably is a minor implementation-specific technicality and has nothing to do with the actual language. The x64 C# 4.0 compiler does tail-recursion optimization, whereas the x86 one doesn't for whatever stupid reason.

Syntactic sugar can usually be worked around to some extent or another, especially if the language has a programmable precompiler (i.e. C's #define).

It might be slightly more meaningful to ask, "does language __ support imperative programming?", and the answer, for instance with Lisp, is "no".

Please, have a look at the beginning of the book: "A-Great-Ruby-eBook". It discusses the very specific topic you are asking. You can do different types of programming in Ruby. If you want to program like functionally, you can do it. If you want to program like imperatively, you can do it. It is a definition question how functional Ruby in the end is. Please, see the reply by the user camflan.