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