If you want to use all features of functional programming with Ruby-like syntax to write modern fast, fault-tolerant applications, you may take a look at Elixir programming language.

What is Elixir?

Elixir is dynamic, functional, concurrent, fast programming language that runs on top of the same virtual machine as his ancestor - Erlang - (BEAM). Elixir was created by José Valim and was inspired by Ruby syntax, but also was influenced by Clojure.

Key principles

Elixir platform itself presents you next availabilities:

• Scalability - Elixir code can runs in thousands and millions lightweight threads that are isolated, but can exchange information via messages.
• Fault-tolerance - Elixir provides supervisors that can restart parts of your applications on errors
• Functional programming - Elixir code is short, elegant and powerful at the same time. You can use pattern matching, immutable constructions, first class functions like in any other functional programming languages.
• Extensibility, DSL - Elixir supports modules, metaprogramming that lets you easily extend language or another modules.
• Erlang compatibility - You can use all of Erlang ecosystem tools and modules in Elixir.
• Tooling - Elixir comes with mix build tool, Hex package manager, IEx interactive shell, ExUnit testing tool.

Features

• UTF-8 support by default.
• Modules and namespaces.
• Docstrings documentation support.
• Everything is an expression.
• Pattern matching.
• Immutability.
• Compiling to Erlang virtual machine bytecode.
• Polymorphism via protocols.
• Lazy and async collections with streams.
• Recursion, high-order functions without side-effects.
• Tail call optimizations.
• Metaprogramming, macroses.
• Simple and lightweight concurrency using Erlang’s mechanisms.

Code examples

 1    IO.puts "Hello Elixir!" # Hello Elixir!
 2
 3    # Integers
 4    255; 0xFF # 255
 5    0b0110 # 6
 6
 7    # Floats
 8    100.0 # 100.0
 9    1.0e-10 # 1.0e-10
10
11    # Booleans
12    true == false; false
13
14    # Atoms - string constants whose name is their value
15    :foo == :bar # false
16
17    # Strings are binaries in Elixir and Erlang:
18    "Hello" # Hello
19
20    # Lists
21    [3.14, :pie, "Apple"]
22    [1] ++ [2] # [1, 2]
23    [1, 2] -- [1] # [2]
24    [head | tail] = [1, 2] # head: 1, tail: [2]
25
26    # Tuples
27    { 3.14, :pie, "Apple" }
28
29    # Keywords lists
30    [foo: "bar"] # foo: "bar"
31
32    # Maps
33    map = %{:foo => "bar"}
34    map[:foo] # "bar"
35
36    # Comprehensions
37    for x <- [1,2,3], do: x * 2 # [2, 4, 6]
38
39    # Pattern matching
40    [1, a] = [1, 2]
41    a # 2
42
43    # Modules
44    defmodule Foo do
45      def bar, do: "bar"
46    end
47    Foo.bar # "bar"
48
49    # Pipe operator
50    "Hello world" |> String.split |> Enum.map(&String.first/1) |> Enum.join # Hw
51
52    # Sigils
53    ~r/abcd/ # Regexp
54    ~s/hello world/ # String
55    ~w/hello world/ # List of words: ["hello", "world"]

Conclusion

If you want to use functional programming language for web-development, fault-tolerant , distributed applications, that you may like an Elixir. It comes with familiar Ruby syntax, but with all of power and eloquence of functional programming languages. Elixir built on top of Erlang platform and you can easily use all of Erlang ecosystem tools and modules in your projects with modern syntax.