DEV Community: Adam Davis

How to Use Head and Tail in Elixir

Adam Davis — Wed, 25 Jan 2023 13:30:00 +0000

Head and tail are a common programming concept used to represent a linked list. While not unique to Elixir lang, it is crucial for understanding the language’s representation of lists.

What do head and tail refer to?

The head of a list is the first element, and the tail is the list containing all the remaining elements.

For example in the list [1, 2, 3, 4], the head would be 1 and the tail would be the list [2, 3, 4].

Head and tail are a recursive representation

If you noticed in the example above, we started with a list, but the tail of that list is also a list that has its own head and tail. This is also true of the tail’s tail, and so on.

What are the head and tail of a list with only one element?

The head of a single element list would be the only element in the list, and the tail would be an empty list.

What are the head and tail of an empty list?

An empty list does not have a head or tail.

How do I get the head and tail of a list in Elixir?

Method 1: hd and tl

The simplest way to get the head or tail in Elixir is with hd/1 or tl/1 respectively:

iex> hd [1, 2, 3]
1
iex> tl [1, 2, 3]
[2, 3]

If we call hd/1 or tl/1 with an empty list, you’ll be given an ArgumentError.

iex> hd []
** (ArgumentError) errors were found at the given arguments:

  * 1st argument: not a nonempty list

    :erlang.hd([])
iex> tl []
** (ArgumentError) errors were found at the given arguments:

  * 1st argument: not a nonempty list

    :erlang.tl([])

Method 2: Pattern matching

To get both head and tail at once, we can use the | operator for pattern matching:

iex> [head | tail] = [1, 2, 3]
[1, 2, 3]
iex> head
1
iex> tail
[2, 3]

But if we only need one of the values, we can still use pattern matching. Just use an underscore to ignore the other value:

iex> [_ | tail] = [1, 2, 3]
[1, 2, 3]

If we try to pattern match head and tail on an empty list, we’ll be given a MatchError.

iex> [head | tail] = []
** (MatchError) no match of right hand side value: []

How to pattern match with head and tail in an Elixir function header

The pattern matching shown above can also be used in a function header to verify that a list is non-empty, while also extracting whichever values you need.

We can test this out by making a function that pattern matches on head and tail, and an overloaded function of the same name that accepts any argument.

def pattern_match_test([_head | _tail]) do
  "pattern match succeeded"
end

def pattern_match_test(_) do
  "pattern match failed"
end

We can see that if we call pattern_match_test/1 with a non-empty list we get the result from the pattern match function, but other types of input will fail the pattern match.

iex> pattern_match_test([1, 2, 3])
"pattern match succeeded"

iex> pattern_match_test([])
"pattern match failed"

iex> pattern_match_test("asdf")
"pattern match failed"

How to use head and tail to add an element to a list in Elixir

Elixir’s head and tail syntax can also be used to add an element to a list.

iex> [1 | [2, 3]]
[1, 2, 3]

The above example shows how we can prepend an element to a list. However, trying to append an element to the end can produce some unexpected results:

iex> [[1, 2] | 3]
[[1, 2] | 3]

This is because the syntax only really supports prepending a head element instead of appending a tail. This is to encourage more efficient operations, because with a linked list is is much faster to add an element to the front of the list instead of the end.

In order to prepend an element, the new node needs to be created and then pointed at the existing list, which becomes the tail.

However, to add an element to the end of a list, we must traverse every element and then point the existing last node of the list to the new element.

It likely wouldn’t cause any issues to add an element to the end of a list once or twice, but if we had a large operation where we appended elements thousands of times the inefficiency would compound.

Real world example: Let’s implement filter!

To put everything together that we’ve learned in this post, we’re going to create an implementation of filter/2 using head and tail.

As with most recursive functions, I like to start with defining a base case. We’ll continue the recursive calls as long as the head is not nil. Once it is nil, we’ll return the reverse order of the list.

def my_filter ([head | tail], f, acc) when head != nil do
    # TODO: implement
end

def my_filter(_list, _f, acc) do
  Enum.reverse(acc)
end

Next we need to define what happens in the recursive case when there is an element in the head of the list. If the function f produces a value of true when given the head of the list, when it should be pushed onto the accumulator. Otherwise, we should keep the accumulator as-is. In both cases, we need to make a recursive call.

def my_filter([head | tail], f, acc) when head != nil do
  if f.(head) do
    my_filter(tail, f, [head | acc])
  else
    my_filter(tail, f, acc)
  end
end

Finally, we need to define the user interface. Because the user doesn’t need to know about the existence of the accumulator, we make a separate function header that does not include the ability to set the accumulator.

def my_filter(list, f) do
  my_filter(list, f, [])
end

To provide a neater interface, we should make every function private except the one we want the user to call.

def my_filter(list, f) do
  my_filter(list, f, [])
end

defp my_filter([head | tail], f, acc) when head != nil do
  if f.(head) do
    my_filter(tail, f, [head | acc])
  else
    my_filter(tail, f, acc)
  end
end

defp my_filter(_list, _f, acc) do
  Enum.reverse(acc)
end

Now let’s test it:

iex> my_filter([1,2,3,4], fn x -> x > 1 end)
[2, 3, 4]

It works!

Now that you’ve read this post and implemented filter, you should have a firm grasp of how to use head and tail in Elixir.

How do you feel about cover letters?

Adam Davis — Wed, 12 Oct 2022 14:45:45 +0000

How do you feel about job applications that ask for a cover letter? Do you skip them if they’re not required?

It seems to me that requiring a cover letter could create an adverse incentive where more qualified employees who have more options would not want to spend the time to write one when there’s other applications that don’t have that same requirement.

Do you personally write cover letters when an application requires one? Or would that requirement make you pass over that role?

How to include static assets in an Elixir application

Adam Davis — Wed, 11 May 2022 11:20:19 +0000

tl;dr

Put your static assets in the /priv directory.
Identify the atom for your app in mix.exs. In this example, we’ll use :my_app.
Get the file path by using Application.app_dir/2.
Read the file according to your project’s needs. One way is with File.stream!/3.

Example:

def get_my_file_stream() do
  Application.app_dir(:my_app, "/priv/my_file.txt")
  |> File.stream!()
end

Diving deeper

If the above info solved your problem, great! You can go ahead and close this page.

But if you want to learn more about this topic, keep reading.

The legacy of OTP

The Elixir programming language is built on top of Erlang/OTP. If you don’t know about Erlang/OTP, check out this page from the Erlang FAQ.

Within Erlang/OTP applications, there is a standard directory structure, which looks like this:

─ ${application}
    ├── doc
    │   ├── internal
    │   ├── examples
    │   └── src
    ├── include
    ├── priv
    ├── src
    │   └── ${application}.app.src
    └── test

The proper directory for storing static assets in these applications is /priv, and Elixir inherits this structure.

If you’d like to see more details on Erlang/OTP applications, check out this page in the OTP Design Principles User’s Guide.

Leveraging the Erlang :code module

Although we used Application.app_dir above, that’s not the only way to get the file path.

Another approach would be to use the Erlang :code module, which you can call directly from your Elixir code (docs here).

The :code module has a function called priv_dir/1 which will return the path to the priv directory for the given application (docs here). Then, you can get the complete path for your file using Path.join/2.

def get_my_file_stream() do
  :code.prive_dir(:my_app)
  |> Path.join("my_file.txt")
  |> File.stream!()
end

How do different types of meetings affect the way you work?

Adam Davis — Wed, 30 Mar 2022 14:02:48 +0000

As I’ve worked with different teams and companies, I’ve noticed that the way meetings are scheduled can have an impact on my productivity. Here’s some different setups I’ve experienced:

Daily standups
Weekly standups
Weekly customer meetings
As few meetings as possible
And more!

What approaches to meetings have you experienced? Which have allowed to perform at your best?

How do you take notes while you code?

Adam Davis — Wed, 23 Mar 2022 13:48:48 +0000

Do you like to take notes when you're writing code?

Do you organize them in some way, or do you only keep notes about your current tasks?

What pieces of information do you think are helpful to keep track of?

What do you wish you knew when you worked you first entry-level tech job?

Adam Davis — Wed, 16 Mar 2022 14:33:07 +0000

No matter how prepared (or not) you felt for your first job in tech, there’s inevitably some things you wish you had done differently.

If you’re in an entry-level job now or hope to be in one soon, what’s something about the industry you want to know more about?

Diving into the macros that make Phoenix controllers work

Adam Davis — Wed, 16 Mar 2022 14:31:12 +0000

You’ve made a Phoenix controller before, but do you know how it actually works? Let’s explore some code together.

Make a new project

First, we’re going to make a new phoenix project. I’m including the --no-ecto flag because I don’t plan on using any database or changeset functionality in this post.

mix phx.new controller_dissection --no-ecto

All the code you need to see will be included in the text of this post. But feel free to follow along by making the project on your machine or by following along with this GitHub repo.

The new project should look something like this (not every file is shown in this tree):

.
├── README.md
├── _build
├── assets
├── config
├── deps
├── lib
│   ├── controller_dissection
│   │   ├── application.ex
│   │   └── mailer.ex
│   ├── controller_dissection.ex
│   ├── controller_dissection_web
│   │   ├── controllers
│   │   │   └── page_controller.ex
│   │   ├── endpoint.ex
│   │   ├── gettext.ex
│   │   ├── router.ex
│   │   ├── telemetry.ex
│   │   ├── templates
│   │   │   ├── layout
│   │   │   │   ├── app.html.heex
│   │   │   │   ├── live.html.heex
│   │   │   │   └── root.html.heex
│   │   │   └── page
│   │   │       └── index.html.heex
│   │   └── views
│   │       ├── error_helpers.ex
│   │       ├── error_view.ex
│   │       ├── layout_view.ex
│   │       └── page_view.ex
│   └── controller_dissection_web.ex
├── mix.exs
├── mix.lock
├── priv
└── test

We haven’t done anything special yet, this is just the default structure for a Phoenix project.

Down the rabbit hole

In this post we’re interested in the controllers. To find them, we need to look in lib/controller_dissectino_web/controllers

You’ll only have one controller by default, and it’s in page_controller.ex. Here’s what it should look like:

defmodule ControllerDissectionWeb.PageController do
  use ControllerDissectionWeb, :controller

  def index(conn, _params) do
    render(conn, "index.html")
  end
end

This line near the top should look pretty familiar if you’ve made a Phoenix controller before:

use ControllerDissectionWeb, :controller

But what does it actually do?

use/2 is a macro that calls the __using__ macro for the given module. Here, the module is ControllerDissectionWeb.

If we open up lib/controller_dissection_web.ex then we’ll see the following __using__ macro defined near the bottom of the file:

@doc """
When used, dispatch to the appropriate controller/view/etc.
"""
defmacro __using__(which) when is_atom(which) do
  apply(__MODULE__, which, [])
end

The __MODULE__ special form provides the atom for the current module, and the which parameter would be :controller, because that’s what’s being passed in with the use call in page_controller.ex.

So all that happens with this use statement is that ControllerDissectionWeb.controller/0 is called.

If we take a look at ControllerDissectionWeb.controller/0 we’ll see the real meat of the Phoenix controller:

def controller do
  quote do
    use Phoenix.Controller, namespace: ControllerDissectionWeb

    import Plug.Conn
    import ControllerDissectionWeb.Gettext
    alias ControllerDissectionWeb.Router.Helpers, as: Routes
  end
end

This function is a macro that will inject code into modules such that they will be able to carry out the defined behavior of Phoenix controllers.

While I won’t get too into the weeds in this post, I encourage you to follow the definition of Phoenix.Controller to see the Phoenix functions that get imported into your controllers.

Injecting our own code into controllers

To test that this code is actually injected into our controllers, we can import a module here and see if we can access it within a controller. It’s generally better to put new modules in a new file, but for simplicity let’s just put it in lib/controller_dissection_web.ex.

Within this new module, we’ll make a simple hello world function:

defmodule HelloWorld do
  def hello_world do
    IO.puts("hello, world!")
  end
end

defmodule ControllerDissectionWeb do
  # ...
end

Now, let’s add an import to the HelloWorld module inside the controller/0 macro:

def controller do
  quote do
    use Phoenix.Controller, namespace: ControllerDissectionWeb

    import Plug.Conn
    import ControllerDissectionWeb.Gettext
    alias ControllerDissectionWeb.Router.Helpers, as: Routes

    import HelloWorld
  end
end

To test out that it’s available, navigate back to lib/controller_dissection_web/controllers/page_controller.ex and try calling hello_world/0 within the index/2 function. If successful, the string "hello, world!" will be printed whenever the index page is loaded.

defmodule ControllerDissectionWeb.PageController do
  use ControllerDissectionWeb, :controller

  def index(conn, _params) do
    hello_world()
    render(conn, "index.html")
  end
end

Now that everything is in place, we’ll run the server with mix phx.server and open up localhost:4000

If all goes well, you should see this in the console:

[info] GET /
hello, world!

What else can we do?

So now that you know how this works, what can you do with this knowledge?

Here’s a few things that come to mind:

common utils library
action handlers that you want to be present on every controller
make a more specific type of controller that calls controller/0 but also has additional functionality

Just for fun, let’s see if we can do a trivial implementation of that last option.

Extending controller functionality

Luckily, for making our own custom type of controller, there’s some existing code in controller_dissection_web.ex that we can use as a reference.

The view_helpers/0 function defines some common functionality that is used in different types of views:

def view do
  quote do
    use Phoenix.View,
      root: "lib/controller_dissection_web/templates",
      namespace: ControllerDissectionWeb

    # Import convenience functions from controllers
    import Phoenix.Controller,
      only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]

    # Include shared imports and aliases for views
    unquote(view_helpers())
  end
end

def live_view do
  quote do
    use Phoenix.LiveView,
      layout: {ControllerDissectionWeb.LayoutView, "live.html"}

    unquote(view_helpers())
  end
end

# ...

defp view_helpers do
  quote do
    # Use all HTML functionality (forms, tags, etc)
    use Phoenix.HTML

    # Import LiveView and .heex helpers (live_render, live_patch, <.form>, etc)
    import Phoenix.LiveView.Helpers

    # Import basic rendering functionality (render, render_layout, etc)
    import Phoenix.View

    import ControllerDissectionWeb.ErrorHelpers
    import ControllerDissectionWeb.Gettext
    alias ControllerDissectionWeb.Router.Helpers, as: Routes
  end
end

The view/0 and live_view/0 functions both provide macros that nest the view_helpers/0 macro within them, allowing for multiple types of views that have some shared functionality. If you take a look around that file, you can find a few other functions that also call view_helpers/0.

All that’s needed to make this work is to pass the nested macro into unquote/1 and follow it up with whatever else you want to include in the macro.

So we can treat controller/0 as the shared code for all controllers, and then make another macro function with a call to controller/0.

First, we need to make a new module with the functionality for the new controller type.

defmodule CustomControllerUtils do
  def flash_hello_world(conn, _opts) do
    conn
    |> Phoenix.Controller.put_flash(:info, "hello, world!")
  end
end

Then, we can make the macro function for our custom controller type. All that’s special about our custom controller is that we’ll have a plug that puts a flash message of “hello, world!” This particular functionality is arbitrary and is only here to demonstrate that you could insert any code you like.

def custom_controller do
  quote do
    unquote(controller())

    import CustomControllerUtils

    plug :flash_hello_world
  end
end

How would you use this?

Have you ever made changes to the Phoenix controller macros? Did this post help you think of a good use case? I’d love to hear about it. Let me know in the comments!

How I built an NYT Spelling Bee solver with Elixir

Adam Davis — Wed, 09 Mar 2022 14:11:41 +0000

While Wordle has caught Twitter feeds by storm, there’s something I love about playing the New York Times Spelling Bee game each morning.

It works by providing a set of letters, and you have to come up with as many words as you can that:

Only use the provided letters
Use the center letter at least once
Are at least 4 characters long

Here’s what a game might look like:

Recently, I took it upon myself to build a solver for this game using Elixir. Most of the code is in this post, but if you'd like to see the whole project you can check it out on GitHub.

Defining success

Because the words in Spelling Bee are curated and intentionally exclude obscure words, we should expect that this program will suggest words that are not included in the solution.

So I’ll be judging the success of this program by the percentage of the solution words that are identified, ignoring suggested words that are not part of the official solution.

Getting a list of words

My approach was pretty simple. I needed to start with a list of English words, then filter based on the criteria of the game.

To get a list of English words, I used the word_list package that I created.

Starting the project

Once I created my new project, I imported my word_list package by adding it in the deps array in mix.exs

defp deps do
  [
    {:word_list, "~> 0.1.0"}
  ]
end

Then, I installed the dependency by running mix deps.get

Test-driven development

Next, I wrote some basic tests so I can define some of the basic functionality.

defmodule SpellingBeeSolverTest do
  use ExUnit.Case
  doctest SpellingBeeSolver

  test "finds some valid words" do
    word_stream = SpellingBeeSolver.solve("t", ["m","y","r","i","f","o"])

    assert "mortify" in word_stream
    assert "fifty" in word_stream
  end

  test "all words include center letter" do
    word_stream = SpellingBeeSolver.solve("t", ["m","y","r","i","f","o"])

    assert Enum.all?(word_stream, fn word -> String.contains?(word, "t") end)
  end
end

These tests make sure that at least some valid words are found, and that all of the words include the center letter.

Writing the code

The solve/2 function takes the following approach:

Get the stream of English words
Apply a filter for length greater than 3, since words must be at least four letters long
Apply a filter that checks that the word contains the center letter
Apply a filter that checks that all letters in the word are either on the edge or the center letter

The following is the contents of the lib/spelling_bee_solver.ex file:

defmodule SpellingBeeSolver do
  def solve(center, edges) do
    WordList.getStream!()
    |> Stream.filter(fn word -> String.length(word) > 3 end)
    |> Stream.filter(fn word -> String.contains?(word, center) end)
    |> Stream.filter(fn word ->
      String.split(word, "", trim: true)
      |> Enum.all?(fn letter -> letter in edges ++ [center] end)
    end)
  end

  def printSolution(center, edges) do
    solve(center, edges)
    |> Enum.each(fn x -> IO.puts(x) end)
  end
end

To print the solution, the inputs can instead be passed to printSolution/2

But does it work?

I tested my program against the solutions of three different days, and my program found all the solutions every time.

Success! ✅

There were several extra words found each time, but since the solutions are a curated set of words this is to be expected.

Room for improvement

While I’m sure there’s more I could do, these are some areas that I think have room for improvement:

It would probably be more convenient to pass in a string for the edges instead of an array of strings
I haven’t done any input validation, so there could be some unexpected behavior if the input isn’t provided in the proper format
Currently, the program must be run in iex or imported into another Elixir project in order to be functional. It would be more practical to put this logic into a cli tool or a web interface.
If this were included as part of a larger project, it would be nice to track which words weren’t part of the previous solutions in order to avoid showing them in the future.

How to import a local module dependency in Elixir

Adam Davis — Thu, 17 Feb 2022 13:27:47 +0000

When you’re in the process of developing a package, it can be useful to be able to import it into another project locally without having to publish it first. By doing this, you can test it within the context of a larger project instead of relying entirely on unit tests.

This guide will show you how to take an Elixir package you’ve made locally and import it into another project using the file path.

Name the dependency

Open the mix.exs file. Look for the project definition, which should look like this:

def project do
  [
    app: :my_dependency,
    version: "0.1.0",
    ...
  ]
end

Make sure to update the name of the app property to whatever you would like to import this package as in other projects.

Get the file path

Copy the complete file path to the root of your package.

Import the package

In the project you’d like to import the package, open your mix.exs file.

Find deps and add your package to the array using the path property:

defp deps do
  [
    {:word_list, path: "/path/to/your_dependency"}
  ]
end

Test with iex

Now you can test whether your project has access to the dependency. Run an iex shell for your project.

iex -S mix

Then, check that you have the ability to run functions from your dependency.

iex> MyDependency.hello
:world

I published my first Elixir package to hex!

Adam Davis — Wed, 19 Jan 2022 13:30:46 +0000

As someone who primarily writes code in JavaScript, I’ve grown accustomed to npm packages existing for pretty much any use case I can come up with. But recently while working on an Elixir project, I came across a situation where an npm package I’ve used previously would be helpful, but I couldn’t find a similar package on hex.

That, of course, is one of the drawbacks to using a language that isn’t as mainstream — there are going to be fewer online resources to take advantage of when you want to find a dependency or find an answer to a question.

The problem I needed to solve

The use case for my project was fairly simple. I needed a way to import a very long list of English words, which I could then filter based on different criteria in my application.

There is a pre-existing npm package called word-list that solves this, and I’ve used it before in another project I worked on. But after doing some searching, I didn’t find anything similar on hex, Elixir’s package manager.

My solution

Since word-list had already compiled a list of English words, I decided to make a clone of that project in Elixir.

You can find my package here and the source code here.

The code

My solution contains a single function that imports the text file containing all the words and makes it available as a stream.

defmodule WordList do
  def getStream!() do
    Application.app_dir(:word_list, "/priv/words.txt")
    |> File.stream!()
    |> Stream.map(fn x -> String.trim(x) end)
  end
end

Additionally, I added a call to Steam.map/2 to trim the new newline character from each word. However, since this is a Stream, that operation is performed lazily. Doing so helps avoid a long initial load time to getting the list of words, and instead pushes off the trim until a word is actually retrieved.

Publishing my package

I found that publishing to hex was pretty easy. I followed this documentation and didn’t run into any issues.

Once I registered an account with hex and filled out the appropriate fields in mix.exs, all I had to do to publish was run mix hex.publish.

Have you published to hex?

If you’ve published any packages to hex before, feel free to share them in the comments. Have you ever run into any difficulties with the process? Have you learned any techniques that streamline the process?

Reading the Elixir source code to learn how if blocks work

Adam Davis — Wed, 12 Jan 2022 12:18:34 +0000

As I’ve been working with Elixir, I’ve been wondering about the ways that macros can be leveraged. So once I realized that if statements are implemented as macros, I figured that reading the source code would be a good way to learn from the creators of the language.

Finding the code

In the Elixir documentation, every function has a </> button that links to its source code. If you follow that button in the documentation for if/2, you’ll find the code that makes if statements work. I’ve pasted it below:

defmacro if(condition, clauses) do
  build_if(condition, clauses)
end

defp build_if(condition, do: do_clause) do
  build_if(condition, do: do_clause, else: nil)
end

defp build_if(condition, do: do_clause, else: else_clause) do
  optimize_boolean(
    quote do
      case unquote(condition) do
        x when :"Elixir.Kernel".in(x, [false, nil]) -> unquote(else_clause)
        _ -> unquote(do_clause)
      end
    end
  )
end

defp build_if(_condition, _arguments) do
  raise ArgumentError,
        "invalid or duplicate keys for if, only \"do\" and an optional \"else\" are permitted"
end

Let’s break this down...

Defining the macro

defmacro if(condition, clauses) do
  build_if(condition, clauses)
end

It starts out by defining a macro for if/2 that accepts the parameters condition and clauses. While the documentation says “this macro expects the first argument to be a condition and the second argument to be a keyword list” there is no programmatic enforcement of that at this level.

Within the macro’s body, all we have is a call to build_if/2 that passes along the unmodified parameters of if/2.

`build_if/2`

defp build_if(condition, do: do_clause) do
  build_if(condition, do: do_clause, else: nil)
end

defp build_if(_condition, _arguments) do
  raise ArgumentError,
        "invalid or duplicate keys for if, only \"do\" and an optional \"else\" are permitted"
end

This is a private function called by the macro and exists in two forms.

The first instance of this function has pattern matching for the clauses argument to only accept a value that starts with do. If the pattern matching succeeds, a call is made to build_if/3 with a value of nil for the else clause.

The second instance does not use pattern matching, but instead has an underscore at the beginning of the parameter names to indicate that their values will not be used. This function raises an ArgumentError to show that the requisite pattern matching for the do clause has not been met.

`build_if/3`

defp build_if(condition, do: do_clause, else: else_clause) do
  optimize_boolean(
    quote do
      case unquote(condition) do
        x when :"Elixir.Kernel".in(x, [false, nil]) -> unquote(else_clause)
        _ -> unquote(do_clause)
      end
    end
  )
end

Note: I’m not quite sure what the purpose of optimize_boolean is, but the source code for it is here if you want to take a look at it. If you know what it’s purpose is, let me know!

This function is where the actual logic of the if is carried out.

It makes use of quote/2 and unquote/1. Quoting returns the internal representation of an expression, and unquoting gets an expression from an internal representation. You can read more about them here.

First, we enter a call to quote/2 and start a case statement that unquotes the condition parameter in order to evaluate it.

Let’s break down the first pattern in the case:

:"Elixir.Kernel".in makes a call to in/2 which is actually just a macro for Enum.member?/2
Enum.member?/2 checks whether an element is within an enumerable
So, :"Elixir.Kernel".in(x, [false, nil]) checks whether x (the condition) is equal to either false or nil

From there, we see that condition evaluating to either false or nil will result in else_clause being returned.

The default case returns the do_clause, which is what we would expect to be returned if the condition was truthy.

Conclusions

We can draw a few interesting observations from reading through this code. The first is that truthiness in Elixir’s if statements is defined as being neither false nor nil. This means that if/2 can be a simple way to test whether a variable has neither of those values.

The other lesson is that macros can work well for implementing control flow. By passing the do and else clauses around as keyword lists, it prevents that code from being run unless we decide it should run.

Which VS Code shortcut do you use the most?

Adam Davis — Wed, 12 Jan 2022 12:17:48 +0000

If VS Code is your primary editor, what’s the shortcut you use most frequently?

Do you have another shortcut you use less frequently, but you enjoy using it a lot?

DEV Community: Adam Davis

How to Use Head and Tail in Elixir

What do head and tail refer to?

Head and tail are a recursive representation

What are the head and tail of a list with only one element?

What are the head and tail of an empty list?

How do I get the head and tail of a list in Elixir?

Method 1: hd and tl

Method 2: Pattern matching

How to pattern match with head and tail in an Elixir function header

How to use head and tail to add an element to a list in Elixir

Real world example: Let’s implement filter!

It works!

How do you feel about cover letters?

How to include static assets in an Elixir application

tl;dr

Diving deeper

The legacy of OTP

Leveraging the Erlang :code module

More content

How do different types of meetings affect the way you work?

How do you take notes while you code?

What do you wish you knew when you worked you first entry-level tech job?

Diving into the macros that make Phoenix controllers work

Make a new project

Down the rabbit hole

Injecting our own code into controllers

What else can we do?

Extending controller functionality

How would you use this?

How I built an NYT Spelling Bee solver with Elixir

Defining success

Getting a list of words

Starting the project

Test-driven development

Writing the code

But does it work?

Room for improvement

More content

How to import a local module dependency in Elixir

Name the dependency

Get the file path

Import the package

Test with iex

More content

I published my first Elixir package to hex!

The problem I needed to solve

My solution

The code

Publishing my package

Have you published to hex?

More Content

Reading the Elixir source code to learn how if blocks work

Finding the code

Defining the macro

build_if/2

build_if/3

Conclusions

More Content

Which VS Code shortcut do you use the most?

`build_if/2`

`build_if/3`