119 lines
2.9 KiB
Elixir
119 lines
2.9 KiB
Elixir
## Sep. 08, 2026 - Braeden Sowinski
|
|
|
|
# h can be used to find info on a function
|
|
h is_boolean
|
|
|
|
# function brackets are optional but recommended
|
|
is_boolean "hello"
|
|
is_boolean(false)
|
|
|
|
3/2 # -> 1.5 results in a float
|
|
div(3,2) # -> 1 results in an int
|
|
|
|
### Atoms
|
|
# - Create atoms by starting with a :
|
|
# ANYTHING that starts with an uppercase is an atom
|
|
## atoms are constants whos value is their own name
|
|
:hello_world
|
|
Hello # is an atom because it starts with uppercase
|
|
|
|
# Similarly module names must start with uppercase, and are therefor atoms
|
|
# e.g.
|
|
Hello = :"Elixir.Hello" # -> true
|
|
|
|
# nil is an atom but nil is built in
|
|
nil
|
|
:nil
|
|
nil == :nil
|
|
|
|
# Short circuits returns second cond
|
|
1 < 2 and false # -> results in false
|
|
1 < 2 and 3 # -> results in 3
|
|
|
|
1 and false # -> errors out, first must be a boolean
|
|
1 && false # -> works
|
|
|
|
# and or not operators
|
|
|
|
# erlang modules start with lowercase and you can call them by using
|
|
# a colon before the module name, this makes it an atom which are modules
|
|
:math.pi
|
|
|
|
# in erlang syntax its math:pi
|
|
|
|
# variables in erlang start with uppercase where in elixir they start with lowercase
|
|
x = 1
|
|
|
|
# variables are immutable but can be rebound
|
|
# i.e. this is a different x
|
|
x = 2
|
|
2 = x
|
|
|
|
# '=' is not an assignment, its a match operator trying to match left to right
|
|
|
|
{x, 2} = {1, 2} # matches, and x becomes 1
|
|
|
|
# you can pin the value of x with ^
|
|
{^x, 2} = {3, 2} # this wont match since x is pinned to 1, and we are trying to match with 3
|
|
|
|
# if a match is successful, it will always return the right hand side of the match
|
|
|
|
{a, "hello", b} = {2, "hello", :atom}
|
|
a # -> 2
|
|
b # -> :atom
|
|
|
|
# you can use x more than once as long as it matches
|
|
{x, x, 1} = {"hello", "world", 1} # -> no match
|
|
{x, x, 1} = {"hello", "hello", 1} # -> matches
|
|
x # -> "hello"
|
|
|
|
### List type
|
|
[1, 2, "hello"]
|
|
|
|
# cons operator is | similar to `||` in ocaml
|
|
[1 |[2, "hello"]] # -> same as above
|
|
[1 | [2 | ["hello"]]] # -> same as above
|
|
|
|
# cons operator can be used to pattern match
|
|
[h | t] = [1, 2, 3]
|
|
h # -> 1
|
|
t # -> [2, 3]
|
|
|
|
[_, x, _, y | _] = [1, "hello", 2, "world", 5]
|
|
x # -> "hello"
|
|
y # -> "world"
|
|
|
|
# `_` can be used to match and just throw that junk away,
|
|
# similarly we can do `| _` to match the remaining to nothing
|
|
|
|
### Anonymous Functions
|
|
f = fn x -> x + 1 end
|
|
|
|
# to call an anon function use .()
|
|
f.(1)
|
|
|
|
String.upcase("hello") # -> "HELLO"
|
|
|
|
# functions passed to other functions need to be anon functions
|
|
Enum.map(["hello", "world"], fn x -> String.upcase(x) end)
|
|
|
|
# Another way to do this is to capture a function to make it anon
|
|
# we specify String.upcase/1 since there are two version of upcase
|
|
# one with /1 argument and another upcase with /2 arguments
|
|
Enum.map(["hello", "world"], &String.upcase/1)
|
|
|
|
Enum.map([1, 2], fn x -> x * x end)
|
|
Enum.map([1, 2], &(&1 * &1)) # captured anon function, &1 is first argument
|
|
|
|
# or
|
|
|
|
Enum.map([1, 2], fn x -> x + 1 end)
|
|
Enum.map([1, 2], &(&1 + 1))
|
|
|
|
# LIST CONCAT / DIFF
|
|
[1, 2] ++ [3, 4]
|
|
[1, 2] -- [1] # -> [2]
|
|
|
|
# STRING CONCAT
|
|
"hello" <> " " <> "world"
|