lecture 02

lectures/02/notes.ex

@@ -0,0 +1,157 @@
+### Bit Strings
+# takes last 3 bits of 12
+# takes last 5 bits of 55
+<<12::3, 55::5>> # result: <<71::size(8)>>
+# 12 = 0b1100
+# 55 = 0b110111
+# becomes 0b10010111 = 151
+
+<<71::7>> # short form of <<71::size(7)>>
+
+is_binary(<<12::3, 55::4>>) # -> false
+# a binary is a bit string where its # of bits is a multiple of 8
+is_binary(<<12::3, 55::5>>) # -> true
+is_binary("hello")
+
+# you can pattern match using bit strings
+<<x::3, y::5>> = <<151>> # 151 = 0b10010111
+# x = 4  = 0b100
+# y = 23 = 0b10111
+
+<<x::3, y::5, z::binary>> = <<151, 255, 55, 66>>
+# works -> x, y pull its from 151
+# z = <<255, 55, 66>> remaining since its a binary
+
+
+<<x::3, y::6, z::bits>> = <<151, 255, 55, 66>>
+# works -> x, y pull bits from 151 and 255 since looking for 9 bits
+# but since 255, 55, 66 are non binary, we canot use z::binary it will fail
+# instead we can use z::bits where z takes up the last remaining bits even
+# if its non-binary (not a multiple of 8)
+
+<<_, x, _, y, __::binary>> = "hello!"
+
+# character(s) 'abc' is okay, but elixir wants you to use
+# ~c"" to specify a char list or a single char
+~c"abc"
+
+String.to_charlist("hello")
+# returns: ~c"hello"
+
+s = "안녕하세요"
+String.to_charlist(s) # -> [50504, 45397, 54616, 49464, 50836]
+Stirng.codepoints(s)  # -> ["안", "녕", "하", "세", "요"]
+
+byte_size(s) # -> 15 bytes
+
+## concat with a 0 byte at end
+s <> <<0>>
+# -> since it cant display the unicodes, it will fallback to actually showing
+# the 15 bytes and the 0 byte
+# -> <<236, 149, 136, 235, 133, 149, 237, 149, 152, 236, 132, 184, 236, 154, 148, 0>>
+
+# valid ascii code will show as a charlist
+[97, 98, 99] # -> ~c"abc"
+?a # -> 97 returns a code
+?b # -> 98...
+
+<<_, ?e, x, _::binary>> = "hello"
+x # -> 108
+
+### LIST COMPREHENSION
+for x <- [3, 2, 7, 6, 8], do: (x + 1)
+for x <- [3, 2, 7, 6, 8], rem(x, 2) == 0, do: (x * x)
+
+### MAPS
+m = %{"a" => 1, :b => "hello", {1, 2} => "world"}
+m[{1, 2}]
+m["a"]
+m[:b]
+
+# though typically the keys are atoms
+# and can be written like this
+m = %{a: 1, b: 2, c: 3}
+m[:a]
+m.a # or since keys are atoms
+
+# pattern matchin on a Map
+%{c: x} = m
+x # -> 3
+
+%{m | c: 4} # returns a new map, but does not assign to original m
+
+for {_, v} <- m, do: v
+# -> [3, 1, 2] returns values as list
+
+# you can use pipe to pipe value to *first argument* of a function
+for {_, v} <- m, do: v |> Enum.sum
+# -> 6
+
+# lets say we want to convert this list to a map
+data = ["homer", 55, "bart", 33, "lisa", 99]
+Enum.chunk_every(data, 2) # -> [["homer", 55], ["bart", 33], ["lisa", 99]]
+for [n, s] <- Enum.chunk_every(data, 2), into: %{}, do: {n, s}
+
+
+s = "नमस्ते"
+for <<c <- s>>, do: c
+# gets the 18 bytes
+
+
+### CREATING PROCESSES
+slow = fn x -> Process.sleep(1000); IO.puts(x) end # simulated slow method
+slow.(1)
+
+f = fn x -> spawn(fn -> slow.(x) end) end
+f.(1)
+
+# lets execute slow 10 times
+Enum.each(1..10, slow) # will take 10 seconds, 1->10
+Enum.each(1..10, f)    # will spawn a process for each 1->10 so only takes 1 second
+
+pid = spawn(fn -> Process.sleep(1000); IO.puts("hello") end)
+# send(pid, "msg") -> send processes message
+# find pid of own processes -> self()
+
+# lets send ourself hello, all processes have a mailbox
+send(self(), "hello")
+
+# we can read from mailbox
+receive do
+  x -> x
+end
+
+send(self(), {1, 2})
+receive do
+  {x, y} -> x + y
+end
+
+# flush will empty the mailbox, and shows
+# all contents the mailbox before flush
+flush
+
+# not advised since processes can be running different elixir versions
+f = fn x -> x * x end
+send(self, f) # function brackets are optional, so self is same as self()
+
+receive do
+  g -> g.(3)
+end
+
+
+# ALIASES
+# alias <name>, as: <alias>
+# e.g.
+# alias ArithmeticServer, as: AS
+
+### FILES
+{:ok, content} = File.read("filename.txt")
+content |> String.split |> Enum.frequencies |> Enum.sort_by(fn {_, v} -> v end, :desc)
+# -> [{"hello", 2}, {"world", 1}]
+
+elem({1, "hello"}, 0) # -> 1
+elem({1, "hello"}, 1) # -> "hello"
+
+# pattern match result to only show most common word, i.e. discard word count
+[{w, _} | _] = content |> String.split |> Enum.frequencies |> Enum.sort_by(fn {_, v} -> v end, :desc)
+w