DEV Community: Maartz

Some Elixir katas - Pt 4

Maartz — Wed, 07 Apr 2021 22:22:36 +0000

For this kata, I'd like to focus on readability.
The kata is "Valid Parentheses", here's the gist.

Write a function that takes a string of parentheses, and determines if the order of the parentheses is valid. The function should return true if the string is valid, and false if it's invalid.

And we got some examples:

"()"              =>  true
")(()))"          =>  false
"("               =>  false
"(())((()())())"  =>  true

So in the stub provided by Codewars, we got this.

defmodule ParenthesesValidator do
  def valid_parentheses(string) do
     # it's empty here   
  end
end

First thing first, we need to get the value from the string parameter and transform it in a list.

One could do:

String.split("()", "")
=> ["", "(", ")", ""]

But the returned list is dirty with the opening and closing "" empty string.

String.split("()", "", trim: true)
=> ["(", ")"]

So we could trim it.

But we also could leverage String.graphemes/1

@spec graphemes(t()) :: [grapheme()]
delegate_to: String.Unicode.graphemes/1
Returns Unicode graphemes in the string as per Extended Grapheme Cluster
algorithm.
The algorithm is outlined in the Unicode Standard Annex #29, Unicode Text
Segmentation (https://www.unicode.org/reports/tr29/).
For details about code points and graphemes, see the String module
documentation.

Examples
iex> String.graphemes("Ńaïve")
["Ń", "a", "ï", "v", "e"]
iex> String.graphemes("\u00e9")
["é"]
iex> String.graphemes("\u0065\u0301")
["é"]

String.graphemes("(())()())")
=> ["(", "(", ")", ")", "(", ")", "(", ")", ")"]

Good, no need to trim and no extra empty strings.

A famous cooker once said, "The key for a great dish is a good reduction, it also work in life in general".
He probably knows Enum.reduce from Elixir library.
And we're going to use it.

In fact, it's better to know what we want to achieve.
The main goal is to be able to determine if we've a closing parentheses for an opened one.

So declare an accumulator which holds the count of encountered "(" and ")".
Furthermore, we'd like to increment the count of this acc when it's a "(" and decrement when it's a ")".

And compare the accumulator to 0 because that'd say we've for each "(" a ")".

defmodule ParenthesesValidator do
  def valid_parentheses(string) do
        string 
        |> String.graphemes
        |> Enum.reduce(0, fn x, acc -> 
            case x do
                "(" -> acc + 1
                ")" -> acc - 1 
                _ -> acc
            end
        end) == 0
  end
end

That's the what we get by using the reduce function.
Inside the modifying function, we use a case clause to increment or decrement the accumulator value.
At the end of the reduction, we compare it to 0 using == 0 to return true or false.

So... it's done right ?

Not really. I omit this test in the suit.

")("              =>  false

But we got a closing and opening parentheses and our accumulator is equal to 0.
So in fact it's not only related to the count but also to the order of apparition.
Thus, we should not be able increment/decrement if the counter is bellow zero. Which means that a closing parentheses would put the accumulator in -1 state.
Then, we should not be able to update it. And return false.

Hopefully, guard clause are here for the rescue.
Elixir's guard clauses are directly inherited from Erlang's one.
One must know that you cannot execute function call in guard clause.

Imagine you'd like to guard on the length of a string, like this:

when String.length(string) > 10 # would fail

But you can do this:

when byte_size(string) > 10 # 🎉

A little [guard clause cheatsheet].(https://kapeli.com/cheat_sheets/Elixir_Guards.docset/Contents/Resources/Documents/index)

So it's good to know that we got powerful tools to describe what we want to achieve.

defmodule ParenthesesValidator do
  def valid_parentheses(string) do
        string 
        |> String.graphemes
        |> Enum.reduce(0, fn x, acc -> 
            case x do
                "(" when acc >= 0 -> acc + 1
                ")" when acc >= 0 -> acc - 1 
                _ -> acc
            end
        end) == 0
  end
end

Here's the final version of it.
Reduce, case with guard are the bread and butter of Elixir, being able to use them will help you achieve more easily your goals.

Thanks for reading and happy coding.

Once again, a nice one:

defmodule ParenthesesValidator do
  def valid_parentheses(string) do
    case Regex.compile(string) do
      {:ok, _} -> true
      {:error, _} -> false
    end
  end
end

Hey but it's a Regex, that's cheating 😂😂😂

Some Elixir katas - Pt 3

Maartz — Wed, 07 Apr 2021 20:24:08 +0000

So let's get started for this 6kyu kata -- I hope I'll do a 5kyu next time.

The gist of this Kata is pretty simple, we've got a list of numbers, and we have to find which one appears an odd number of times.

    FindOdd.find([20,1,-1,2,-2,3,3,5,5,1,2,4,20,4,-1,-2,5]) # 5
    FindOdd.find([1,1,2,-2,5,2,4,4,-1,-2,5]) # -1
    FindOdd.find([10]) # 10

That's pretty straight forward and when I've read it I knew I was going to use Enum.reduce, it's not the only way to achieve it obviously but that's what comes in my mind.

As usual I'll also share another solution at the end of this post.

defmodule FindOdd do
    def find([]), do: []
    def find([x]), do: x
    def find(list), do: list
end

So I've choose to use function clauses over multiples private function being called by the find one.

With these 3 clauses all cases are covered.

I want to create a Map where the key is the number in the list and the value is the number of times we encounter it, like this %{10: 1}.

Hence the Map I want to use, the shape of my data will looks like this {x, y}, and because I do not really care of the number of times at the end, it's going to be much like this {x, _}.

def find(list) do
    {x, _} = 
        list
        |> Enum.reduce(%{}, fn x, acc -> Map.update(acc, x, 1, &(&1 + 1))end)
        |> Enum.find(fn {_,y} -> rem(y, 2) == 1 end)
    x
end

Let's analyze this bit by bit.

I take the list and pass it to the Enum.reduce/3 function.
The first argument is the list itself, the second is where I want to accumulate the data and the third is the lambda.

If x is present in map with value of 1, &(&1 + 1) is invoked with argument 1 and its result is used as the new value of x in my acc which is a Map.

I could have decoupled it but for the sake of simplicity and because it's not really the topic of this post I'll keep it like this.

So once I've got my reduced Map I still need to find where it's odd, and as I said earlier, it's explicitly told that there's only one odd value.
I just need to find in my Map -- a map implements the protocol Enumerable so I can call Enum module functions on my Map -- with the help of Enum.find, which takes the Enum and a lambda.

Here I just pass y because it's the value I want to get the reminder of.
The Kernel.rem/2 or just rem function gives us back the reminder of the division, also named the modulo, and I want to it to equal to 1 when x is divided by 2.

After this, I just need to return x et voila.

It was a really simple problem, and because it is simple there's a tons of way to solve it.

My favorite is this almost one liner function.

defmodule FindOdd do
  import Bitwise
  def find(list), do: Enum.reduce(list, &Bitwise.bxor/2)
end

The usage of bitwise operators is a field where I do not really perform so well, I recall having used it for solving a problem on Codewars too in a JS kata.
It will maybe be part of a future blog post!

Thanks for reading and happy coding.

Some Elixir katas - Pt 2

Maartz — Wed, 07 Apr 2021 20:11:09 +0000

I'm gonna talk about the "Josephus Permutation" kata on Codewars.

It's time to tackle this one.

So what's the gist of this?

This problem takes its name by arguably the most important event in the life of the ancient historian Josephus: according to his tale, he and his 40 soldiers were trapped in a cave by the Romans during a siege.

Refusing to surrender to the enemy, they instead opted for mass suicide, with a twist: they formed a circle and proceeded to kill one man every three, until one last man was left (and that it was supposed to kill himself to end the act).

Not so funny for a kata though.

Well, Josephus and another man were the last two and, as we now know every detail of the story, you may have correctly guessed that they didn't exactly follow through the original idea.

Oh great.

You are now to create a function that returns a Josephus permutation, taking as parameters the initial array/list of items to be permuted as if they were in a circle and counted out every k places until none remained.

So here it starts.
Let's get the function definition.

Tips and notes: it helps to start counting from 1 up to n, instead of the usual range 0..n-1; k will always be >=1.
For example, with n=7 and k=3 josephus(7,3) should act this way.

[1,2,3,4,5,6,7] - initial sequence
[1,2,4,5,6,7] => 3 is counted out and goes into the result [3]
[1,2,4,5,7] => 6 is counted out and goes into the result [3,6]
[1,4,5,7] => 2 is counted out and goes into the result [3,6,2]
[1,4,5] => 7 is counted out and goes into the result [3,6,2,7]
[1,4] => 5 is counted out and goes into the result [3,6,2,7,5]
[4] => 1 is counted out and goes into the result [3,6,2,7,5,1]
[] => 4 is counted out and goes into the result [3,6,2,7,5,1,4]

And so the final result is:

josephus([1,2,3,4,5,6,7],3)==[3,6,2,7,5,1,4]

Rather than going step by step like I did in the previous one. I'm going to write the full code and then commenting the reasons. Furthermore, we'll go through a solution which is much more idiomatic than mine... and very elegant.

defmodule Josephus do
  def permutation(items, k) do
    doperm(items, k - 1, k, [])
  end

  defp doperm([], _i, _k, r), do: Enum.reverse(r) # Get the list back reversed

  defp doperm(items, i, k, r) do
    j = rem(i, length(items)) # Get the new index
    {p, items} = List.pop_at(items, j) # pop the item at the given index
    # Call the function with the new tail and populate the accumulator list with the popped num
    doperm(items, j + k - 1, k, [p | r])
  end
end

Here, we've 3 functions in the Josephus module, permutation and two doperm.

The defp is a keyword to declare a private function, like in a Ruby file under private keyword or in a Java class.

So permutation is somehow the public access to our module and it makes a call to doperm function, but which one?

Since Elixir supports multiclauses function like multiples languages, commonly called overcharging, we can leverage the pattern matching and, compared to the function argument, infer which one will be called.

So the last doperm function is getting called right now, because all the parameters are needed, and especially, the first one is not an empty list.
Check this out:

defp doperm([], _i, _k, r) # first arg is empty list, _i _k are ignored and r is needed
defp doperm(items, i, k, r) # first is called items thus a list, and the rest is used too

Well, Elixir is a functional language, so we need to find a way to get a new list with our items popped out of the primary list, mutate it and get the index/key of where we are in this one.

That's a lot of work but recursion is here. So this is going to be smooth.

In fact, that's the responsibility of doperm function, until it gets an empty list.
How this works?

defp doperm(items, i, k, r) do
  j = rem(i, length(items)) # Get the new index
  {p, items} = List.pop_at(items, j) # pop the item at the given index
  # Call the function with the new tail and populate the accumulator list with the popped num
  doperm(items, j + k - 1, k, [p | r])
end

This function waits for 4 arguments, a list, an index, a key and the rest.

NB : excuse my poor naming for variables but ... I've got no excuse 🤷‍♂️

So I declare a variable j which is equal to the remainder of the passed index divide by the length of the passed list. This will be where I'll pop the item from the list.

The List.pop_at() function returns a tuple if we refer to the doc, it looks like this:

iex> List.pop_at([1, 2, 3], 0)
{1, [2, 3]}
iex> List.pop_at([1, 2, 3], 5)
{nil, [1, 2, 3]}

So I can grab the poped out value, and the updated list. Great.

{p, items} = List.pop_at(items, j)
# pop the item at the given index
# returns a new items list modified

Unfortunately, it's done. I mean, literally, the last line is just calling our doperm function with the arguments correctly placed.

Oh we can check this still !

doperm(items, j + k - 1, k, [p | r])

Here, I pass the freshly created items list, based on the return value of the List.pop_at function. Then, I add j which was the index where I popped the value at, to k which is the key, or maybe should have been call it the step, minus 1 because in real life we start counting from 1. Then I still pass the k or step, and then I update r or rest with my p. With the help of the cons operator |.

Et voila.

And to be efficient, we need to know how Elixir works under the hood, especially with lists.

When manipulating a list, is easier to add the value at the beginning and reverse it rather than go through each element and place the item popped to the end. Elixir let us do this easily with this piece of syntax [p|r], where p is the head and r is the tail.

iex> a = [1,2,3,4,5,6,7]
[1,2,3,4,5,6,7]
iex> b = [-2,-1,0 | a]
[-2,-1,0,1,2,3,4,5,6,7]

I've already talked of this feature of Elixir in a previous post.

Still, we got a list but, reversed... That's the job of doperm. Hooray.

What ??

Yes.

First doperm function clause was:

defp doperm([], _i, _k, r)

We wait for an empty list as the first argument. We do not care of the index and the key OR step and we expect the rest. And when we get r we just pass it through the Enum.reverse function to ... reverse it.

So we've constructed our list idiomatically without losing performance and we go through it once to reverse it. So far so good. Our mission is over.

This was a tricky exercise for a newcomer like me in the Elixir world, in the functional programming paradigm, but it was challenging and that's what we love, don't we ?

And for the more elegant and idiomatic code, see:

defmodule Josephus do
  def permutation(items, k) do
    Stream.unfold({items, length(items) - 1}, fn
      {[], _} ->
        nil

      {it, index} ->
        index = rem(k + index, length(it))
        {val, it_prime} = List.pop_at(it, index)

        {val, {it_prime, index - 1}}

    end)
    |> Enum.to_list()
  end
end

This is a beautiful piece of Elixir code.
Which for performance sake use the lazy version of Enum.unfold, Stream.unfold.
Streams are very powerful to manipulate undetermined potentially gigantic computation.

They probably worth a post.

Some Elixir katas - Pt 1

Maartz — Wed, 07 Apr 2021 19:55:21 +0000

During the previous quarantine I've decided to get some katas. Usually I tend to go on Exercism to grab some exercises.

But I've choose CodeWars to get fresher and community-driven exercises.

The plot is the following, you've 8 levels, called kyus, from 8 kyu to 1 kyu. Eight being the lowest or easiest level and one the tougher, much more a project than a real exercise.

I've made some 8, 7 and 6 level kyus, and last night I go my very first 5 kyu exercise. During this day I've passed a second one, and for the sake of explanation and writing, I want to go through the solving of both 5 kyu exercises in a series, maybe more.

Let's go

5kyu -- RGB to Hex Conversion

Here's the details

The rgb function is incomplete. Complete it so that passing in RGB decimal values will result in a hexadecimal representation being returned. Valid decimal values for RGB are 0 - 255. Any values that fall out of that range must be rounded to the closest valid value. Note: Your answer should always be 6 characters long, the shorthand with 3 will not work here. The following are examples of expected output values:

So we expect this:

Kata.rgb(255, 255, 255) # returns FFFFFF
Kata.rgb(255, 255, 300) # returns FFFFFF | It's false on purpose
Kata.rgb(0,0,0)         # returns 000000
Kata.rgb(148, 0, 211)   # returns 9400D3 | This is purple

So first thing first, we need to grab the value passed in the function and put them in a list

def rgb(r,g,b) do
    [r,g,b]
end

In an iex session, we can check this out:

iex(1)> Kata.rgb(255,255,255)
[255, 255, 255]

Then, we should worry about this Kata.rgb(255, 255, 300) call. As I said before, it's false on purpose and we should take care of this. There's many ways to do so, like pattern matching, guard clauses etc. But I've decided to leverage the huge Elixir's standard library.

There's in fact two interesting functions in the Kernel module, min and max.

Let's map through each element of the list.

def rgb(r,g,b) do
    [r,g,b]
    |> Enum.map(fn x -> x |> max(0) |> min(255) end)
end

Presto, we give constraints to our inputs.

iex(2)> RGB.rgb(255,255,300)
[255, 255, 255]

That's great, so

After this, we need to somehow transform our 255 to FF.
Elixir's Integer module gives us a very good function: to_string.

If I refer to this function documentation, here's what it can do:

@spec to_string(integer(), 2..36) :: String.t()

Returns a binary which corresponds to the text representation of integer in the given base.

base can be an integer between 2 and 36.

Inlined by the compiler.

## Examples

    iex> Integer.to_string(100, 16)
    "64"

    iex> Integer.to_string(-100, 16)
    "-64"

    iex> Integer.to_string(882_681_651, 36)
    "ELIXIR"

That's sweet because it totally fits our needs. We need a base 16 since it's hexadecimal.

Let's do this.

def rgb(r,g,b) do
    [r,g,b]
    |> Enum.map(fn x -> x |> max(0) |> min(255) end)
    |> Enum.map(fn x -> Integer.to_string(x, 16) end)
end

And still in iex

iex(3)> Kata.rgb(255,255,300)
["FF", "FF", "FF"]

Recall the Kata.rgb(0,0,0) call in the katas detail?

iex(4)> Kata.rgb(0,0,0)
["0", "0", "0"] # 000

Ughh... not really what we expect though.

Kata.rgb(0,0,0) # We expect this output: 000000

So we need to find a way to add those missings zeros.
Once again, the Elixir standard library come in handy!

This time, it's the String module with the pad_leading function.

Returns a new string padded with a leading filler which is made of elements from the padding.

Here's what we can read about it in the documentation.
Great, let's do this.

def rgb(r,g,b) do
    [r,g,b]
    |> Enum.map(fn x -> x |> max(0) |> min(255) end)
    |> Enum.map(fn x -> Integer.to_string(x, 16) end)
    |> Enum.map(fn x -> String.pad_leading(x, 2, "0") end)
end

We want to pad our input with 0 to get a string with a length of two
Still in iex

iex(5)> Kata.rgb(255,255,300)
["FF", "FF", "FF"]
iex(6)> Kata.rgb(0,0,0)
["00", "00", "00"]

At this point, we've almost finished the kata. We just need to join our list to be a single string. The Enum.join() will do the job.
Here what the full code looks like:

defmodule Kata do
    def rgb(r,g,b) do
        [r,g,b]
        |> Enum.map(fn x -> x |> max(0) |> min(255) end)
        |> Enum.map(fn x -> Integer.to_string(x, 16) end)
        |> Enum.map(fn x -> String.pad_leading(x, 2, "00") end)
        |> Enum.join()
    end
end

And in iex it runs this way.

iex(7)> RGB.rgb(0,0,0)
"000000"
iex(8)> RGB.rgb(255,255,300)
"FFFFFF"

So far so good, this 5 kyu kata is complete.
The pipe operator |> is very helpful in this scenario. Indeed, it let us think in function composition and also let the data flow through the functions. Each function gives us back a new list based on the passed one. We just need to pass a list and it give us back a list. Pretty neat!

This article comes from my personal blog.

Elixir and Javascript syntax comparison

Maartz — Thu, 24 Sep 2020 13:31:11 +0000

On a daily basis at work I use 2 languages. Java and Javascript.
Doing Javascript everyday and learning Elixir, I recognize some patterns. Let's recap.

Nobody ignores in the web dev planet the features that ES6 ships to the Javascript language, especially the functional ones.

Summary

Objects vs Modules
Method chaining vs Pipe Operator
Destructuring vs Pattern Matching
High Order Functions

Objects vs Modules

With ES6, the class keyword and all the OO ceremony come in Javascript.
In Elixir, as a functional language, it doesn't support the idea of Object, instead, we've Modules, which can be seen as bucket or namespace for functions.

Example of an Object in Javascript:

const Circle = {
  PI: Math.PI, // Math.PI is a constant
  area: r => Circle.PI * (r ** 2),
  circumference: r => Circle.PI * (r * 2)
};

Circle.area(2) // 12.56...

Same in Elixir:

defmodule Circle do
  @pi :math.pi() # Here we define a module constant

  def area(r), do: @pi * (r * r)
  def circumference(r), do: 2 * @pi * r
end

Circle.circumference(5) # 31.41..

So in my opinion, I've gained some good habits from FP, like writing little functions, which are responsible of a ~~tiny modification of the input~~ new output based on the one passed, and the modification asked. So that's what we call a reducer.
And this, let us build very complex data transitioning with ease, so it leads us naturally to the next step: Method Chaining vs Pipe Operator.

A bit of background: Erlang and Elixir

In a precedent example, I've used :math.pi() which is not an Elixir module, here's why.
Unlike Javascript, Elixir does not have a Math module, instead, it leverage the Erlang standard library. In fact, Elixir is built on top of Erlang. Furthermore, Elixir and Erlang are interoperable. Which means we can use the huge ecosystem of Erlang libraries in our Elixir code. That's pretty neat.
So to call an Erlang module in Elixir, we just have to type the following:

:erlang_module.erlang_function()
:math.pi()
:crypto.hash(:md5, data) # To use crypto library and hash with MD5

Method Chaining vs Pipe Operator

So here we are going to take a real-world example, squaring a list of numbers and reducing the value to a single one. So we can use in both languages the map and reduce functions.

Javascript

const numbers = [1,2,3,4,5]\
let sumOfSquares = list
  .map(num => num * num)
  .reduce((num, acc) => acc + num)

In Elixir, we will use the pipe operator

list_of_numbers = [1,2,3,4,5]
sum_of_squares =
  list_of_numbers
  |> Enum.map(&(&1 * &1))
  |> Enum.reduce(&(&1 + &2))

Two things here which are Elixir specific, first the |> aka pipe operator and second, this exotic piece of syntax '&(&1)'.

So the pipe operator let us pass the data from a function call to another in a Unix shell fashion. But, as uncle Ben told us, with great power comes great responsibility, well ... kidding, here there's just one rule, your first function parameter should be the output of the previous function. That's all. So map in both Javascript and Elixir returns an Array or a List (same thing but different naming).

To truly leverage this pipe operator, you must think in function composition. Here's an example for a simple scrapper that I wrote.
I needed to perform a call to a specific URL, handle the 301 HTTP status, get the correct URL and then make a new call to the properly formatted URL.

def get_url(ean) do
    HTTPoison.start()
    url =
      "#{@url}-#{ean}" # Module constant here
      |> HTTPoison.get!() # Call to another Module function
      |> get_html() # Module function
      |> get_title() # Module function
      |> List.to_string() # List Module function call
      |> split() # Module function
  end

So this pipe operator avoid one thing, function call hell like this:

function3(function2(function1(data))) // works but we loose readability

The pipe operator put the data where it should be. At the top of the attention, after all, that's what we are processing.

As far as I recall, it seems that the pipe operator is in a proposal stage at the TC39. Anyway, it's also available in ReasonML, so in React-Reason.

And what if I told that we can extract data of a variable easily by just describing what we want ?

Destructuring vs Pattern Matching

In Elixir, we say x = 1, you probably think that x is equal to 1. But there's a subtle difference, we do not say this is equality, we say its a match. The value behind x is 1 because we have bind the free variable named x to match the value of 1. So the = sign is called the match operator and not equal.

Thinks of this as a comparison between the Rhs and the Lhs. See how we can leverage this.

Taking MDN docs, destructuring is:

The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.

So:

let a, b, rest;
[a, b, ...rest] = [10, 20, 30, 40, 50]; // ... or spread operator
a // 10
b // 20
rest // [30, 40, 50]

In Elixir:

list = [1,2,3,4,5]
a, b = list
** (SyntaxError) iex:2: syntax error before: ','

Oh, it seems that it doesn't work like in Javascript... So here, list is a List type. And in Elixir, a list is a made of a head and a tail like this [head | tail] ( the pipe here is called the cons operator).
Thus, we can write a list like this [1 | [ 2 | [ 3 ]]].
Lets do this in the Elixir fashion.

list = [1,2,3,4,5]
[a|b] = list
a # 1
b # [2,3,4,5]

# One more time
[a, b, c|d] = list
a # 1
b # 2
c # 3
d # [4,5]

In Javascript, destructuring is really great, especially in function parameters.

Like in this React component, instead of calling props.title, props.imageUrl, etc.
I choose to destructure the props parameter and cherry-pick the values I want to get from.

render() {
  return (
   <div className="directory-menu">
    {
     this.state.sections.map(({title, imageUrl, id, size}) => (
      <MenuItem key={id} title={title} imageUrl={imageUrl} size={size} />
     ))
    }
   </div>
  );
 }

As I did in this Elixir snippet:

def draw_image(
  %Identicon.Image{color: color, pixel_map: pixel_map})
  do
    image = :egd.create(250, 250)
    fill = :egd.color(color)

    Enum.each pixel_map, fn({start, stop})  ->
      :egd.filledRectangle(image, start, stop, fill)
    end

    :egd.render(image)
  end

To extract the values from the Identicon.Image struct, I pattern matched on the fields of the passed struct in the function parameter. But what if we can call functions in function parameters?

High Order Function

In Elixir, function are first-class citizens, so a function can take a function as a parameter and/or return a function.

So let's get a non-trivial example!

// In ES6 style
const multiplyAll = array => times => array.map(
  item => item * times
);

// In ES5 style
var multiplyAll = function multiplyAll(array) {
  return function (times) {
    return array.map(function (item) {
      return item * times;
    });
  };
};

multiplyAll([2,7,3,60])(2) // [4, 14, 6, 120]

This what we call 🍛 🙌 CURRYFICATION 🍛 🙌!

We can see in ES5 style that we have a function, which returns a function, which uses a method with a lambda AKA anonymous...function!

Yo Dawg, I've heard you like functions so we put functions in your functions which returns functions in the function body... 🤔

In fact it helps a lot. See, we can leverage this style to prevent side effects, and aims pure functions.

In Elixir, we can do this, this way:

# Here we declare a lambda called run_query
run_query =
  fn query_def ->
    Process.sleep(2000)    ①  
    "#{query_def} result"
  end

# Here another lambda with the previous one inside.
async_query =
  fn query_def ->
    spawn(fn -> IO.puts(run_query.(query_def)) end)
  end

# And finally, we use this lambda in another function call
Enum.each(1..5, &async_query.("query #{&1}"))

# Naively we can achieve this this way
add = fn x ->
  fn y -> x + y end
end

add.(1).(3) # 4

This ends the Javascript vs Elixir article, the main goal is not to make a real comparison between the languages but much more leverage the strength of one language to write better code.

As I said earlier, since I've begun my Elixir journey, I realize how I can leverage Elixir's idioms and philosophy to write better Javascript, and vice-versa.

Kudos to you if you have reach the end of this.

Give IEx a memory

Maartz — Sun, 03 Nov 2019 13:16:02 +0000

I guess I'm not the only one here to use IEx during my Elixir session.
It's the REPL for Elixir, you can tinker with it, etc.

But, hey, if you read this you already know that.

So, IEx is good but maybe dumb. Everytime you exit IEx, you've to type everything back, it can be -- it is -- tedious.

So to give IEx a memory, just add this line to your shell config file.
For me it's in my .zshrc file.

export ERL_AFLAGS="-kernel shell_history enabled"

And voilà ! Your IEx session will remember it's previous command and just key up to whatever line you've want to pickup. 😎