Forem: Rhaenyra

Lists and tuples in Elixir

Rhaenyra — Sun, 23 Jun 2024 12:54:49 +0000

We will keep learning two of the most used collection data types in Elixir: lists and tuples. They are immutable!

Like lists, tuples can hold any value. In Elixir data structure they are immutable, so every operation will return a new List or a new Touple.

(Link)List

Elixir uses square brackets to specify a list of values. List operators never modify the existing list. You can freely pass the data around with the guarantee that no one will mutate it in memory—only transform it.

Linked lists hold zero, one, or more elements in the chosen order.

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

iex> [1, "two", 3, :four]
[1, "two", 3, :four]

iex> [1, 3, "two", :four]
[1, 3, "two", :four]

iex> length([1, 2, 3])
3

List concatenated

Two lists can be concatenated or subtracted using the ++/2 and --/2 operators.

left ++ right

Concatenates a proper list and a term, returning a list. If the right operand is not a proper list, it returns an improper list. If the left operand is not a proper list, it raises an ArgumentError.
left -- right

List subtraction operator. Removes the first occurrence of each element in the left list for each element in the right list.

iex>[1] ++ [2,3]
[1, 2, 3]
iex> [1, 2, 3] ++ [4, 6, 6]
[1, 2, 3, 4, 5, 6]
iex>[1, 2] ++ 3 
[1, 2 | 3] 
iex> [1, 2] ++ {3, 4} 
[1, 2 | {3, 4}] 

iex> [1, 2, 3] -- [1, 2]
[3]
iex> [1, 2, 3, 2, 1] -- [1, 2, 2]
[3, 1]
iex> [1, 2, 3] -- [2] -- [3]
[1, 3]
iex> [1, 2, 3] -- ([2] -- [3])
[1, 3]
iex> [1, true, 2, false, 3, true] -- [true, false]
[1, 2, 3, true]

List prepended

An element can be prepended to a list using |. Due to their cons cell-based representation, prepending an element to a list is always fast (constant time), while appending becomes slower as the list grows in size (linear time):

iex(1)> new = 0
iex(2)> list = [1, 2, 3]
iex(3)> [new | list]
[0, 1, 2, 3]

iex(1)>list = [1, 2, 3]
iex(2)[0 | list] # fast
[0, 1, 2, 3]
iex(3)list ++ [4] # slow
[1, 2, 3, 4]

Head and tail of list

Lists in Elixir are effectively linked lists, which means they are internally represented in pairs containing the head and the tail of a list.

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

The head is the first element of a list and the tail is the remainder of the list. They can be retrieved with the functions hd/1 and tl/1

hd(list)

Returns the head of a list. Raises ArgumentError if the list is empty.
tl(list)

Returns the tail of a list, which is the list without its first element. Raises ArgumentError if the list is empty.

iex> hd([1, 2, 3, 4])
1
iex> hd([1 | 2])
1
iex> hd([])
** (ArgumentError) argument error

iex> tl([1, 2, 3, :go])
[2, 3, :go]
iex>tl([:a, :b | :improper_end])
[:b | :improper_end]
iex>tl([:a | %{b: 1}])
%{b: 1}
iex>tl([:one])
[]
iex>tl([])
** (ArgumentError) argument error

Tuples

Elixir uses curly brackets to define tuples. Tuples store elements contiguously in memory, which means accessing a tuple element by index or getting the tuple size is a fast operation. Indexes start from zero.

iex> {}
{}
iex> {:ok, "hello"}
{:ok, "hello"}
iex> {1, :two, "three"}
{1, :two, "three"}
iex> tuple_size({:ok, "hello"})
2
iex(1)> tuple = {:ok, 1, "hello"}
{:ok, 1, "hello"}
iex(2)> tuple_size(tuple)
3

Functions for working

Accessing a tuple element with elem/2, put_elem/3, and tuple_size/1.

elem/2(tuple, index)

Gets the element at the zero-based index in tuple. Raises ArgumentError when the index is negative or out of range of the tuple elements.
put_elem/3(tuple, index, value)

Puts value at the given zero-based index in tuple.
tuple_size/1(tuple)

Returns the size of a tuple, which is the number of elements in the tuple.

iex(1)> tuple = {:ok, 1, "hello"}
{:ok, 1, "hello"}
iex(2)> elem(tuple, 1)
1

iex> elem({:ok, "hello", 1}, 1)
"helo"
iex> elem({}, 0)
** (ArgumentError) argument error
iex> elem({:foo, :bar}, 2) 
** (ArgumentError) argument error

iex> put_elem({:foo, :ok, 3}, 2, 4)
{:foo, :ok, 4}
iex(1)> tuple = {:foo, :bar, 3}
iex(2)> put_elem(tuple, 0, :baz)
{:baz, :bar, 3}

iex(1)> tuple = {:ok, 1, "hello"}
{:ok, 1, "hello"}
iex(2)> tuple_size(tuple)
3

File.read/1

The File module is an interface module that provides an interface to the file system. The read(path) function returns a tuple with the atom :ok as the first element and the file contents as the second. Elixir allows us to pattern match on tagged tuples and effortlessly handle both success and failure cases.

iex> File.read("path/to/existing/file")
{:ok, "... contents ..."}
iex> File.read("path/to/unknown/file")
{:error, :enoent}

What is the difference between lists and tuples?

iex > list = [1, 2, 3] 
[1, 2, 3]

# This is fast as we only need to traverse `[0]` to prepend to `list` 
iex > [0] ++ list [0, 1, 2, 3]

# This is slow as we need to traverse `list` to append 4
iex > list ++ [4] [1, 2, 3, 4]

#When you update a tuple, all entries are shared between the old and the new tuple, except for the entry that has been replaced
iex >tuple = {:a, :b, :c, :d}
{:a, :b, :c, :d}

iex >put_elem(tuple, 2, :e)
{:a, :b, :e, :d}

Final Thoughts

This wraps up today's introduction to collection data types in Elixir: Lists and Tuples. If you haven't read the previous article, Basic types in Elixir, be sure to check it out. Our next article will delve into Pattern matching. Make sure not to miss it. I hope this article helps you. See you next time, bye!

Basic types in Elixir

Rhaenyra — Mon, 03 Jun 2024 11:43:10 +0000

Before introducing the basic data types of Elixir, let's briefly introduce how to identify basic functions. This will help you read the code examples later.

How to Identify functions and documentation

Functions in Elixir are identified by both their name and their arity. The arity of a function describes the number of arguments the function takes.

The Elixir shell defines the h function, which you can use to access documents for any function

h trunc/1 works because it is defined in the Kernel module.
Kernel module is Elixir's default environment.
All functions in the Kernel module are automatically imported into our namespace.

Basic types

Basic arithmetic

iex> 1 + 2 
3
iex> 5 * 5
25

Operation /
The operation / always returns float instead of integer

iex > 10 / 2
5.0

Operation division or get the division's remainder

notice that Elixir allows you to drop the parentheses when invoking functions that expect one or more arguments.

iex> div(10, 2)
5
iex> div 10, 2
5
iex> rem 10, 3
1

Elixir also supports shortcut notations for entering binary, octal, and hexadecimal numbers:

iex> 0b1010
10
iex> 0o777
iex> 511
iex> 0x1F
31

Floats in Elixir are 64-bit precision.
Float numbers require a dot followed by at least one digit and also support e for scientific notation:

iex> 1.0
1.0
iex> 1.0e-10
1.0e-10

You can invoke the round function to get the closest integer to a given float, or the trunc function to get the integer part of a float.

iex> round(4.58)
5
iex> trunc(2.58)
2

Booleans

Elixir supports true and false as booleans:

iex > true
true
iex> true === false
false

Elixir also provides three boolean operators: or/2, and/2, and not/1.
or/2 and and/2These operators are strict in that they expect something that evaluates to a boolean as their first argument.
Requires only the left operand to be a boolean since it short-circuits. If the left operand is not a boolean, a BadBooleanErrorexception is raised.
If the not/1 value is not boolean, an ArgumentError exception is raised.

iex> true or false
true
iex> false or 30
30
iex> 30 or false
** (BadBooleanError) expected a boolean on left-side of "or", got: 30

iex> true and false
false
iex> false and true
false
iex> true and "hello"
"hello"
iex> false and "hello"
false
iex> "hello" and true
** (BadBooleanError) expected a boolean on the left-side of "and", got: 
"hello"

iex> not false 
true
iex> not true
false

nil

Elixir also provides the concept of nil, to indicate the absence of a value and a set of logical operators that also manipulate nil: ||/2, &&/2 and !/1].
For these operators, false and nil are considered "falsy", all other values are considered "truthy".

iex> nil || true
true
iex> false || nil
nil
iex> nil || false
false
iex> nil || 1
1
iex> 1 || nil
1

iex> nil && 13
nil
iex> 13 && nil
nil
iex> nil && false
nil
iex> false && nil
false

iex> !nil
true

Atoms

An atom is a constant whose value is its name. Some other languages call these symbols.
They are often useful to enumerate over distinct values Often they are used to express the state of an operation, by using values such as :ok and :error.
Atoms are equal if their names are equal and Elixir allows you to skip the leading : for the atoms false, true, and nil.

iex> :apple
:apple
iex> :banana
:banana

iex> :apple ==:apple
true
iex> :apple == :banana
false

iex> true == :true
true
iex> is_atom(false)
true
iex> is_atom(:false)
true

String

Strings in Elixir are UTF-8 encoded binaries.
It is a sequence of Unicode characters, typically written between double quoted strings, such as "hello" and "héllò".
And you can use the binary concatenation operator <>/2. Concatenates two binaries.
If one of the sides isn't binaries, will raise an ArgumentError

iex> "hello"
hello

iex> "hello" <> "world"
"helloworld"
iex> "hello " <> "world"
"hello world"

iex(1)> "foo" <> x = "foobar"
"foobar"
iex(2)> x
"bar"

iex> x <> "bar" = "foobar"
(ArgumentError) cannot perform prefix match because the left operand of <> has an unknown size

Elixir supports string interpolation on both sides and supports any data type that may be converted to a string and can have line breaks in them using escape

iex(1)> string = "world"
iex(2)> "hello #{string}!"
 "hello world!"

iex(1)> string = "Hello"
iex(2)> "#{string} world!"
"Hello world!"

iex(1)> number = 24
iex(2)> "i am #{number} years old!"
"i am 24 years old!"

iex(1)> "hello
...(1)>  world"
"hello\nworld"
iex> "hello\nworld"
"helo\nworld"

You can use IO.puts/1.
This function is from the IO module, the IO function handling input/output (IO).
Notice that the IO.puts/1 function returns the atom :ok after printing.

iex> IO.pust("hello\nword")
hello
world
:ok

Strings in Elixir are represented internally by contiguous sequences of bytes known as binaries and we can get the number of bytes a string

iex> is_binary("hello")
true
iex> is_binary("hellö")
true

iex> byte_size("hello")
5
iex> byte_size("hellö")
6

Notice that the number of bytes in that string is 6, even though it has 5 graphemes. That's because the grapheme "ö" takes 2 bytes to be represented in UTF-8. We can get the actual length of the string, based on the number of graphemes, by using the String.length/1 function will return the number of Unicode graphemes in a UTF-8 string.

iex> String.length("hello")
5
iex> String.length("hellö")
5
iex> String.length("涼涼")
2

The [String]module contains a bunch of functions that operate on strings as defined in the Unicode standard like downcase/2 and upcase/2.
The downcase/2 gives string to lowercase according to mode and upcase/2 gives string to uppercase according to mode.

iex> String.downcase("ABCD")
"abcd"
iex> String.downcase("AB 123 XPTO")
"ab 123 xpto"
iex> String.downcase("OLÁ")
"olá"
iex> String.upcase("abcd") 
"ABCD" 
iex> String.upcase("ab 123 xpto") 
"AB 123 XPTO" 
iex> String.upcase("olá") 
"OLÁ"

Predicate function

We work with different data types, we will learn Elixir provides several predicate functions to check for the type of a value.
For example, the is_integer can be used to check if a value is an integer or not.
If you want to know other the predicate functions you can check the below link 👇
Other the predicate functions

is_integer(1)
true
is_integer(2.0)
false

Structural comparison

Elixir also provides ==, !=, <=, >=, < and > as comparison operators. We can compare numbers but also atoms, string, and booleans can do.
Integers and floats compare the same if they have the same value but if you use the strict comparison operator === and !== if you want to distinguish between integers and floats they are different.

iex> 1 == 1 
true 
iex> 1 != 2 
true 
iex> 1 < 2 
true
iex> "foo" == "foo"
true
iex> "foo" == "bar"
false

iex> 1 == 1.0
true
iex> 1 == 2.0
false
iex> 1 === 1.0
false

The comparison operators in Elixir can compare across any data type. We say these operators perform structural comparison.
For more information, you can click below link 👇
Structural vs Semantic comparisons.

Other tips

Elixir also supports shortcut notations for entering binary, octal, and hexadecimal numbers:

iex> 0b1010
10
iex> 0o777
511
iex> 0x1F
31

Float numbers require a dot followed by at least one digit and also support e for scientific notation:

iex> 1.0
1.0
iex> 1.0e-10
1.0e-10

This wraps up today's introduction to basic data types. If you haven't read the previous article, How to get start Elixir, go give it a read. Our next article will delve into lists and tuples as data types. Make sure not to miss it. See you next time, bye!

How to get start Elixir

Rhaenyra — Sun, 02 Jun 2024 11:45:40 +0000

What is the Elixir?

Elixir is a dynamic functional programming language built on top of the Erlang BEAM virtual machine, for building scalable and maintainable applications. creating low-latency, distributed, and fault-tolerant systems.

How to Install

I use mac so the image is how to install in mac
Other operating systems can click the link to read👇
Other Operation Systems

Interactive mode

We can type any Elixir expression in interactive mode and get its result.

I will always support you! Share my experience of being sexually assaulted.

Rhaenyra — Tue, 19 Mar 2024 13:27:45 +0000

‼️trigger warning: This article contains images of sexist assaults.

I was sexually assaulted by trolls on the Taiwain's Internet. Since I am a self-taught web developer and woman.

Hi everyone my name is Rhaenyra, and I'm from Taiwan. Today I want to share a story about gender discrimination and how we can move forward to bring positivity to the tech industry. By sharing my experience, I aim to empower every woman in the tech industry with a simple yet powerful message:

" I will always support you!"

I'm a self-taught web developer who jumped into job hunting three months after I started learning. My first gig was as a software developer intern, and within another seven months, I scored my second job offer as a front-end developer and another internship.

I decided to share my career switch story and some free resources on YouTube because, when I was looking to switch careers, all my Google searches (in Chinese) results pretty much told me it was a no-go, especially for someone diving into self-study. But when I search in English, I find loads of resources, solid advice, and encouraging words. So, I want to bring this inclusive culture into my living environment. I dropped my first YouTube video to spill the beans on my journey, aiming to boost up anyone out there thinking about leaping.

Since, my video got shared on a forum, and that's when things took a bit of a turn. Some folks started dropping comments on the forum and, unfortunately, left some sexually assaulted messages under my videos. The one that got the most attention was this one comment saying that, as a woman, I supposedly got my job based on my looks and figure. Like the text in the screenshot below, these are just some of the comments.

Seeing that comment for the first time really threw me for a loop. I was a mix of frustrated and ticked off. I'm never bragging about how epic I am or flashing job offers from big names. I've just used a well-known company in my video banner as a smart marketing move, but hey, I never claimed to have snagged an offer from FAANG or anything.

My whole point is to encourage folks who are feeling a bit scared or unsure about following their dreams.

And yet, here I am, getting heat simply because I'm a woman... and because I am self-taught... I almost let it get to me. But then, it hit me: why should anyone's opinion sway me just because of my gender, something I was born with? A few days later, I saw some uplifting comments and noticed a bunch of folks in the foreign communities that are outside the Chinese-speaking community rallying for gender equality. It was like a shot of energy. I realized I wasn't alone, so I picked myself up and told myself to keep pushing and learning.

I reminded myself to stay strong, like Ada Lovelace, the first programmer, and like those encouraging voices in the comments and community. Being strong means you can share your story to help others, letting them know they're not in this alone. The most crucial part? To keep moving forward. That's how we make our voices heard in the tech world and take a stand against discrimination.

Finally, I want to say to everyone, especially those who are going through tough times. I've been there too, and I totally get where you're coming from. Just remember, even when it feels like you're all on your own, there are people out there ready to have your back. Count me in as one of them. I'm here for you, always.