DEV Community: Alex Cosmas

Understanding Protocols in Elixir

Alex Cosmas — Sat, 30 Mar 2024 18:10:41 +0000

Protocols in Elixir are a way to define a set of functions that a module must implement. They are similar to interfaces in other programming languages.

In Elixir, protocols are used to define a common set of functions that a module must implement, but they do not enforce the implementation details.

Example: Card Game

Let's say you have a group of friends who want to play a game together. The game requires each player to have a set of skills, such as the ability to roll a dice, draw a card, or move a piece on a board. However, each player has their own unique way of implementing these skills.

In Elixir, you can define a protocol for the game that specifies the functions that each player must implement. For example, the GamePlayer protocol might have functions like roll_dice, draw_card, and move_piece.

Now, let's say you have two friends, Alice and Bob, who want to play the game. Alice is a beginner and wants to implement the GamePlayer protocol in a simple way, while Bob is an expert and wants to implement it in a more complex way.

Alice might implement the roll_dice function by simply rolling a physical dice and returning the result. She might implement the draw_card function by drawing a card from a deck and returning its value. And she might implement the move_piece function by moving a piece on the board a certain number of spaces.

Bob, on the other hand, might implement the roll_dice function by using a statistical model to simulate the roll of a dice. He might implement the draw_card function by using a machine learning algorithm to predict the value of the card. And he might implement the move_piece function by using a physics engine to simulate the movement of the piece on the board.

Even though Alice and Bob have implemented the GamePlayer protocol in different ways, they can still play the game together because they both implement the same functions. This is similar to how protocols work in Elixir.

In Elixir, you can define a protocol using the defprotocol macro. For example:

defprotocol GamePlayer do
  def roll_dice
  def draw_card
  def move_piece
end

Now, any module that wants to implement the GamePlayer protocol must implement these three functions.

For example, Alice's simple implementation of the GamePlayer protocol might look like this:

defmodule Alice do
  def roll_dice, do: 1 + 1
  def draw_card, do: 10
  def move_piece, do: 5
end

Bob's more complex implementation of the GamePlayer protocol might look like this:

defmodule Bob do
  def roll_dice, do: simulate_dice_roll()
  def draw_card, do: predict_card_value()
  def move_piece, do: simulate_piece_movement(5)

  def simulate_dice_roll, do: ...
  def predict_card_value, do: ...
  def simulate_piece_movement(spaces), do: ...
end

Even though Alice and Bob have implemented the GamePlayer protocol in different ways, they can still play the game together because they both implement the same functions.

This is the power of protocols in Elixir. They allow different modules to implement the same functions in different ways, making it easier to write reusable code and create more flexible programs.

Guards in Elixir

Alex Cosmas — Tue, 28 Nov 2023 09:27:48 +0000

Guards in Elixir are used within function definitions to impose constraints on the input parameters. They act as filters, allowing a function clause to be selected only when certain conditions are met.

Here are some key points about guards:

Guards are conditions added to function clauses using the when keyword:

def some_function(arg) when condition do
  # Function body
end

Supported Constructs:

Basic Operators: Guards support basic comparison operators (==, !=, >, <, >=, <=) and boolean operators (and, or, not).
Type Checks: Type checks using is_integer/1, is_float/1, is_atom/1, is_boolean/1, is_list/1, etc., to ensure the type of the argument.
Pattern Matching: Guards also allow pattern matching using the match?/2 function.

Examples:

Here are some examples to illustrate guards in action:


# Function to double a number if it's less than 10
def double_if_less_than_ten(x) when x < 10 do
  x * 2
end

# Function to greet if the argument is a string
def greet_person(name) when is_binary(name) do
  "Hello, #{name}!"
end

# Function to check if a list has more than 3 elements
def has_more_than_three_elements(list) when is_list(list) and length(list) > 3 do
  true
end

Limitations:

Guard clauses have some limitations due to their constrained nature. They are executed in a restricted environment and therefore don't support arbitrary functions or complex computations. They must be pure and quick to execute, as they run before the function body and should not have side effects.

Use Cases:

Guards are beneficial when you want to specify conditions for function clauses based on the type or value of arguments. They help in making code more expressive and maintainable by separating different cases for function invocation.

Elixir leverages guards extensively in pattern matching and function definition, allowing you to create more flexible and precise functions that handle various input scenarios elegantly.

What is the -> arrow in Elixir

Alex Cosmas — Tue, 28 Nov 2023 08:12:18 +0000

-> is a fundamental part of the Elixir syntax and plays several roles but first what is it.
The -> arrow is used to denote function clauses, as well as to define anonymous functions.

1. Defining Function Clauses
In pattern matching, the -> arrow separates the function head (which includes the function name and its arguments) from the function body.
For example:

defmodule Math do
  def sum(a, b) do
    a + b
  end
end

Here, def sum(a, b) do ... end is a function clause, and the -> arrow is implied within the do ... end block.

Anonymous Functions
When creating anonymous functions using the fn keyword, the -> arrow separates the arguments and body of the function.
For example:

add = fn a, b -> a + b end

In this case, fn a, b -> a + b end defines an anonymous function that takes a and b as arguments and returns their sum (a + b). The -> arrow separates the arguments from the function body.

The -> arrow is crucial for indicating the separation between the arguments and the function body in both function definitions and anonymous functions in Elixir.

Google Geocoding API error: request denied

Alex Cosmas — Sun, 23 Jul 2023 16:59:01 +0000

I ran into this issue while trying to use the Geocode gem on my rails 7 app.

If you ran into this error, these are the steps that I used to debug.
Google Bard was a great tool that helped with solving this bug.

Why? Google Geocoding API error: request denied.

The Google Geocoding API error "request denied" can occur for a few reasons:

You have not activated the Geocoding API in the Google Cloud Console.
You have not specified the key parameter in your request.
The key parameter does not match the API key in your Google Cloud Console.
Your API key has not been correctly set up in the Google Cloud Console.
You have exceeded your monthly quota for free requests.
You are using a restricted IP address or country.

To troubleshoot this error, you can check the following:

Make sure that the Geocoding API is activated in your Google Cloud Console.
Check that you have specified the key parameter in your request.
Verify that the key parameter matches the API key in your Google Cloud Console.
Check your monthly quota for free requests.
Check that you are not using a restricted IP address or country.

Solution

Installing the Geocode gem to rails

Install the Geocoder gem:
bundle add geocoder
Create a config/initializers/geocoder.rb file and add the following code:
Ruby Geocoder.configure do |config| config.api_key = ENV['GEOCODER_API_KEY'] config.lookup_adapter = :google end
Replace ENV['GEOCODER_API_KEY'] with your Google Geocoding API key.
You can get your API key from the Google Cloud Console: https://console.cloud.google.com/apis/credentials.
In your Rails application, you can now use the Geocoder class to geocode addresses.

For example, the following code will geocode the address "1600 Pennsylvania Avenue NW, Washington, DC 20500":

Ruby address = "1600 Pennsylvania Avenue NW, Washington, DC 20500" coordinates = Geocoder.search(address).first.coordinates

The coordinates variable will now contain the latitude and longitude of the address.

Here are some additional resources that you may find helpful:

Geocoder gem documentation: https://github.com/alexreisner/geocoder
Google Geocoding API documentation: https://developers.google.com/maps/documentation/geocoding/

Results

What is the difference npm build and npm run build?

Alex Cosmas — Thu, 23 Mar 2023 07:48:05 +0000

One more thing, npm build and npm run build are two different things, npm run build will do custom work written inside package. json and npm build is a pre-defined script (not available to use directly).

Resource
https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&cad=rja&uact=8&ved=2ahUKEwiAnbHGx_H9AhWexgIHHUu6AsIQFnoECAsQAQ&url=https%3A%2F%2Fstackoverflow.com%2Fquestions%2F43664200%2Fwhat-is-the-difference-between-npm-install-and-npm-run-build&usg=AOvVaw3u7JIq9QOJYXkUCxvrDsqn

How do I comment out (multiline) in Rails?

Alex Cosmas — Tue, 07 Mar 2023 14:16:18 +0000

Easiest way out is to use <-- --> to comment out your code as show below.


Example

Dynamic Navigation - How to Render Nav-Items Dynamically in a Next App

Alex Cosmas — Wed, 10 Nov 2021 13:31:07 +0000

I came by this article by Caleb Olojo which I found quite useful.

If you have a scenario where you need to render navigation links dynamically, you need to go through this link.

He did a really great job explaining his process.

Happy hacking and thanks again Caleb.

Link:
https://www.freecodecamp.org/news/dynamic-navigation-in-nextjs/
https://www.freecodecamp.org/news/author/calebolojo/

Browserslist: caniuse-lite is outdated. Please run: npx browserslist@latest --update-db

Alex Cosmas — Thu, 28 Oct 2021 07:34:27 +0000

While trying the run my server in NextJs, I encountered the below error.

Browserslist: caniuse-lite is outdated. Please run: npx browserslist@latest --update-db

These following steps worked for me and I hope this help you out.

Run the following commands,

rm -rf node_modules/
yarn
yarn upgrade caniuse-lite browserlist
restart your server

If you still encounter the same issue, try clearing your browser cache.