Elixir for Python programmers

• Python homepage, hg repo (git mirror), bug tracker
• PyPy homepage, hg repo, bug tracker

• Elixir homepage, git repo, bug tracker
• Erlang homepage, git repo, bug tracker

• CPython uses a combination of reference-counting and a separate tracing collector to clean up islands created by reference cycles.
• PyPy does not use reference counting but instead a generational mark-and-sweep collector with incremental major collections.

• .py for source files
• .pyc, .pyo for compiled bytecode

• .ex for source files that are to be compiled
• .exs for source files that are to be interpreted
• .beam for compiled BEAM bytecode

• python
• python3
• ipython for some use cases

• iex
• iex -S mix to start with modules loaded from your mix project

• Ctrl-d on Linux
• Ctrl-z, Return on Windows

• Ctrl-c, Ctrl-c
• Ctrl-c, a, Enter
• Ctrl-g, q, Enter

_

(underscore)

v()

help(func)

h func

True
False
None

true
false
nil

• "string" is a bytestring in Python 2.x, and unicode in Python 3.x
• u"string" is unicode
• b"string" is a bytestring

• "string" is an Erlang binary with UTF-8 encoding
• 'string' is an Erlang list with 6 codepoints,
  [115, 116, 114, 105, 110, 103]

• Elixir docs: Binaries, strings and char lists
• Lists of numbers are sometimes mis-printed as characters and vice versa.

Named functions can not be defined at the top-level scope (including the REPL) or in another function; they can only be in a defmodule declaration:

defmodule MyModule do
  def add(x, y) do
    x + y
  end
end

MyModule.add(2, 3)
# => 5

Elixir supports defining multiple functions of the same name with different patterns or arities:

defmodule MyModule do
  def op("double", n) do
    n + n
  end

  def op("square", n) do
    n * n
  end

  def op(n) do
    n * n * n
  end
end

MyModule.op("double", 10)
# => 20
MyModule.op("square", 10)
# => 100
MyModule.op(10)
# => 1000

Optional arguments must be listed last:

def add(x, y=3):
    return x + y

add(2)
# => 5

Even though Python's collections and objects are generally mutable, default parameters e.g. y=dict() are evaluated only when the function is defined, not on every function call.

Optional arguments can be listed at any position, as long as they do not conflict with an existing declaration:

defmodule MyModule do
  def add(x, y \\ 3) do
    x + y
  end
end

MyModule.add(2)
# => 5

or

defmodule MyModule do
  def add(x \\ 10, y) do
    x + y
  end
end

MyModule.add(2)
# => 12

With both examples above, Elixir defines two separate functions, MyModule.add/1 and MyModule.add/2.

square = lambda n: n ** 2
square(10)
# => 100

square = fn n -> n * n end
square.(10)
# => 100

print(obj)

IO.puts(obj)

print(obj, end='')

IO.write(obj)

No pipe operator, unless you want to use macropy. In many cases, of course, the returned object has a relevant method for further processing:

" hello world ".strip().upper()
# => 'HELLO WORLD'

The |> pipe operator works like Clojure's -> thread-first macro:

" hello world " |> String.trim |> String.upcase
# => "HELLO WORLD"

which is equivalent to:

String.upcase(String.trim(" hello world "))    
# => "HELLO WORLD"

list(n * n for n in [1, 2, 3, 4])
# => [1, 4, 9, 16]

list(map(lambda n: n * n, [1, 2, 3, 4]))
# => [1, 4, 9, 16]

for n <- [1, 2, 3, 4], do: n * n
# => [1, 4, 9, 16]

Enum.map([1, 2, 3, 4], fn n -> n * n end)
# => [1, 4, 9, 16]

list(map(str.upper, ["hello", "world"]))
# => ['HELLO', 'WORLD']

The function must be captured with the & operator:

["hello", "world"] |> Enum.map(&String.upcase/1)
# => ["HELLO", "WORLD"]

assert x == 3, "not 3"

Elixir doesn't have an assert in Kernel, but you can use the one in ExUnit.Assertions:

import ExUnit.Assertions, only: [assert: 1, assert: 2]

assert x == 3, "not 3"

You can also "assert" with pattern matching or by pinning a variable with ^. The downside is that may get a less-informative error on failures:

x = 2

^x = 3
# => ** (MatchError) no match of
# =>    right hand side value: 3

{:ok, val} = {:fail, nil}
# => ** (MatchError) no match of
# =>    right hand side value: {:fail, nil}

' text \n'.strip()
# => 'text'

" text \n" |> String.trim
# => "text"

' text \n'.rstrip()
# => ' text'

" text \n" |> String.trim_trailing
# => " text"

' text \n'.lstrip()
# => 'text \n'

" text \n" |> String.trim_leading
# => "text \n"

' hello world '.split(' ')
# => ['', 'hello', 'world', '']

" hello world " |> String.split(" ")
# => ["", "hello", "world", ""]

'hello world again'.split(' ', 1) # max splits
# => ['hello', 'world again']

"hello world there" |> String.split(" ", parts: 2)
# => ["hello", "world there"]

'hello world'.upper()
# => 'HELLO WORLD'

"hello world" |> String.upcase
# => "HELLO WORLD"

'HELLO WORLD'.lower()
# => 'hello world'

"HELLO WORLD" |> String.downcase
# => "hello world"

'hello world'.replace("l", "x")
# => 'hexxo worxd'

"hello world" |> String.replace("l", "x")
# => "hexxo worxd"

'hello world'.replace("l", "x", 1)
# => 'hexlo world'

"hello world" |> String.replace("l", "x", global: false)
# => "hexlo world"

'*' * 20
# => '********************'

"*" |> String.duplicate(20)
# => "********************"

"\u0067\u0308" |> String.length
# => 1
# Note: g̈

len(u"\u0067\u0308")
# => 2

"\u0067\u0308" |> String.to_charlist |> length
# => 2

len(u"\u0067\u0308".encode('utf-8'))
# => 3

"\u0067\u0308" |> byte_size
# => 3

"ello" in "hello world"
# => True

"hello world" |> String.contains?("ello")
# => true

'hello world'.startswith('hello')
# => True

"hello world" |> String.starts_with?("hello")
# => true

'hello world'.endswith('hello')
# => False

"hello world" |> String.ends_with?("hello")
# => false