Fix file names (#2987)

Fix file names

* fix file names

* fix file names

* fix file names

* fix file names

* fix file names

* Fixed file name

* fixed file name

* fixed file name

* fixed file name

* fixed file name

* fixed file name

* fixed file name

1 files changed, 0 insertions, 470 deletions

diff --git a/sk-sk/elixir.html.markdown b/sk-sk/elixir.html.markdown
deleted file mode 100644
index 2401f92e..00000000
--- a/sk-sk/elixir.html.markdown
+++ /dev/null
@@ -1,470 +0,0 @@
----
-language: elixir
-contributors:
-    - ["Joao Marques", "http://github.com/mrshankly"]
-    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
-    - ["Ryan Plant", "https://github.com/ryanplant-au"]
-translators:
-  - ["Peter Szatmary", "https://github.com/peterszatmary"]
-lang: sk-sk
-filename: learnelixir-sk.ex
----
-
-Elixir je moderný funkcionálny jazyk vytvorený nad Erlang VM (virtuálnym
-strojom). Je plne kompatibilný s Erlangom, ale ponúka viac štandardnú syntax
-a množstvo funkcií.
-
-```Elixir
-
-# Jednoriadkový komentár začína symbolom #
-
-# Neexistuje viacriadkový komentár, avšak je možné vyskladať za sebou viac
-# jednoriadkových komentárov.
-
-# Pre spustenie Elixir shellu zadajte príkaz `iex`
-# Kompiláciu zdrojových kódov vykonáte príkazom `elixirc`
-
-# Obe príkazy by sa už mali nachádzať v path pokiaľ ste nainštalovali elixir
-# správne.
-
-## ---------------------------
-## -- Základné typy
-## ---------------------------
-
-# Čísla
-3    # integer
-0x1F # integer
-3.0  # float
-
-# Atómy, sú literály, konštanty s rovnakým menom. Začínajú s `:`.
-:ahoj # atom
-
-# Tzv. Tuples sú v pamäti uložené súvisle.
-{1,2,3} # tuple
-
-# Pristúpiť k tuple elementu vieme pomocou funkcie `elem`:
-elem({1, 2, 3}, 0) #=> 1
-
-# Zoznamy sú implementované ako linkované zoznamy.
-[1,2,3] # zoznam
-
-# Vieme pristúpiť k hlavičke (head) a chvostu (tail) zoznamu:
-[head | tail] = [1,2,3]
-head #=> 1
-tail #=> [2,3]
-
-# V Elixire, rovnako ako v Erlangu, `=` znamená pattern matching a nie
-# klasické priradenie.
-#
-# To znamená, že ľavá strana (pattern / vzor) je postavená oproti pravej
-# strane.
-#
-# Takto funguje aj príklad vyššie s čítaním hlavičky a chvosta zoznamu.
-
-# Pattern match končí chybou ak sa obe strany nezhodujú, v tomto príklade majú
-# tuples rôznu veľkosť.
-# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
-
-# Binárne typy
-<<1,2,3>> # binary
-
-# Reťazce a zoznamy znakov
-"ahoj" # reťazec
-'ahoj' # zoznam znakov
-
-# Viacriadkový reťazec
-"""
-Ja som viacriadkový
-reťazec.
-"""
-#=> "Ja som viacriadkový\nreťazec.\n"
-
-# Reťazce sú kódované v UTF-8:
-"héllò" #=> "héllò"
-
-# Reťazce sú skutočne iba binárne typy, a zoznamy znakov sú iba zoznamy.
-<<?a, ?b, ?c>> #=> "abc"
-[?a, ?b, ?c]   #=> 'abc'
-
-# `?a` v elixire vráti ASCII číselnú reprezentáciu pre znak `a`
-?a #=> 97
-
-# Pre spájanie zoznamov sa používa `++`, pre binárne typy `<>`
-[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
-'ahoj ' ++ 'svet'  #=> 'ahoj svet'
-
-<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
-"Ahoj " <> "svet"  #=> "ahoj svet"
-
-# Rozsahy sú reprezentované ako `začiatok..koniec` (obe inkluzívne)
-1..10 #=> 1..10
-dolna..horna = 1..10 # Na rozsahy možno použiť rovnako pattern matching
-[dolna, horna] #=> [1, 10]
-
-# Mapy sú páry kľúč-hodnota
-pohlavia = %{"david" => "muž", "gillian" => "žena"}
-pohlavia["david"] #=> "muž"
-
-# Mapy s kľúčmi reprezentovanými atómami môžu byť použité takto
-pohlavia = %{david: "muž", gillian: "žena"}
-pohlavia.gillian #=> "žena"
-
-## ---------------------------
-## -- Operátory
-## ---------------------------
-
-# Trošku matematiky
-1 + 1  #=> 2
-10 - 5 #=> 5
-5 * 2  #=> 10
-10 / 2 #=> 5.0
-
-# V elixire operátor `/` vždy vráti float (reálne číslo).
-
-# Pre celočíselné delenie sa používa `div`
-div(10, 2) #=> 5
-
-# Pre celočíselné delenie so zvyškom `rem`
-rem(10, 3) #=> 1
-
-# Boolean operátory: `or`, `and` a `not`.
-# Tieto operátori očakávajú ako svoj prvý argument boolean.
-true and true #=> true
-false or true #=> true
-# 1 and true    #=> ** (ArgumentError) argument error
-
-# Elixir tiež poskytuje `||`, `&&` a `!` , ktoré akceptujú argumenty
-# ľubovoľného typu.
-# Všetky hodnoty okrem `false` a `nil` budú vyhodnotené ako true.
-1 || true  #=> 1
-false && 1 #=> false
-nil && 20  #=> nil
-!true #=> false
-
-# Pre porovnávanie máme: `==`, `!=`, `===`, `!==`, `<=`,
-`>=`, `<` a `>`
-1 == 1 #=> true
-1 != 1 #=> false
-1 < 2  #=> true
-
-# `===` a `!==` sú viac striktné pri porovnávaní celých čísel (integer) a
-# desatinných čísel (float).
-1 == 1.0  #=> true
-1 === 1.0 #=> false
-
-# Vieme porovnať dokonca dva rôzne údajové typy:
-1 < :ahoj #=> true
-
-# Celkové poradie triedenia:
-#
-# číslo < atom < referencia < funkcia < port < pid < tuple < zoznam < bitový
-# string
-
-# Výrok Joe Armstronga: "Aktuálne poradie nie je dôležité, ale
-# dôležité je to, že celkové poradie je dobre definované."
-
-## ---------------------------
-## -- Riadenie toku
-## ---------------------------
-
-# `if` výraz
-if false do
-  "Toto nebude nikdy videné"
-else
-  "Toto bude"
-end
-
-# Existuje aj `unless`
-unless true do
-  "Toto nebude nikdy videné"
-else
-  "Toto bude"
-end
-
-# Pamätáte sa na pattern matching? Mnoho štruktúr pre riadenie toku v
-# elixire sa spoliehajú práve na pattern matching.
-
-# `case` dovolí nám porovnať hodnotu oproti mnohým vzorom:
-case {:one, :two} do
-  {:four, :five} ->
-    "Toto nebude zhodné"
-  {:one, x} ->
-    "Toto bude zhodné a nastaví `x` na hodnotu `:two` "
-  _ ->
-    "Toto bude zhodné z ľubovoľnou hodnotou."
-end
-
-# Je zvyčajné nastaviť hodnotu do `_` ak ju nepotrebujete.
-# Napríklad, ak je pre nás potrebná iba hlavička zoznamu (head):
-[head | _] = [1,2,3]
-head #=> 1
-
-# Pre lepšiu čitateľnosť môžme urobiť nasledovné:
-[head | _tail] = [:a, :b, :c]
-head #=> :a
-
-# `cond` dovoľuje kontrolovať viac podmienok naraz.
-# Použite `cond` namiesto vnorovania mnohých `if` výrazov.
-cond do
-  1 + 1 == 3 ->
-    "Nebudem nikdy videný"
-  2 * 5 == 12 ->
-    "Ani ja"
-  1 + 2 == 3 ->
-    "Ja budem"
-end
-
-# Je bežné nastaviť poslednú podmienku rovnajúcu sa `true` , ktorá bude vždy
-# zodpovedať.
-cond do
-  1 + 1 == 3 ->
-    "Nebudem nikdy videný"
-  2 * 5 == 12 ->
-    "Ani ja"
-  true ->
-    "Ale ja budem (je to v podstate vetva else)"
-end
-
-# `try/catch` sa používa na zachytenie hodnôt, ktoré boli vyhodené, takisto
-# podporuje `after` klauzulu, ktorá je zavolaná vždy, či bola hodnota
-# zachytená alebo nie.
-try do
-  throw(:ahoj)
-catch
-  message -> "Mám #{message}."
-after
-  IO.puts("Som after klauzula.")
-end
-#=> Som after klauzula
-# "Mám :ahoj"
-
-## ---------------------------
-## -- Moduly a funkcie
-## ---------------------------
-
-# Anonymné funkcie (všimnite si bodku)
-stvorec = fn(x) -> x * x end
-stvorec.(5) #=> 25
-
-# Takisto akceptujú viax klauzúl a tzv. stráže (guards).
-# Stráže vám umožnia pattern matching ešte viac zlepšiť, tieto časti sú
-# označené kľúčovým slovom `when`:
-f = fn
-  x, y when x > 0 -> x + y
-  x, y -> x * y
-end
-
-f.(1, 3)  #=> 4
-f.(-1, 3) #=> -3
-
-# Elixir tiež poskytuje množstvo vstavaných funkcií.
-# Tie sú dostupné v aktuálnom scope (viditeľnej oblasti).
-is_number(10)    #=> true
-is_list("hello") #=> false
-elem({1,2,3}, 0) #=> 1
-
-# Možno zgrupovať viac funkcií do jedného modulu. V module použite `def`
-# na definíciu funkcie.
-defmodule Matematika do
-  def sucet(a, b) do
-    a + b
-  end
-
-  def na_druhu(x) do
-    x * x
-  end
-end
-
-Matematika.sucet(1, 2)  #=> 3
-Matematika.na_druhu(3) #=> 9
-
-# Na zkompilovanie našeho Matematika modulu ho uložte ako `math.ex`  a použite
-# `elixirc` v termináli: elixirc math.ex
-
-# V module môžme definovať funkcie s `def` a privátne funkcie s `defp`.
-# Funkcia definovaná s `def` je možné volať z iných modulov, privátne funkcie
-# môžu byť volané iba lokálne.
-defmodule SukromnaMatematika do
-  def sucet(a, b) do
-    rob_sucet(a, b)
-  end
-
-  defp rob_sucet(a, b) do
-    a + b
-  end
-end
-
-SukromnaMatematika.sucet(1, 2)    #=> 3
-# SukromnaMatematika.rob_sucet(1, 2) #=> ** (UndefinedFunctionError)
-
-# Deklarácie funkcií tiež podporujú stráže (guards) a viacnásobné klauzuly:
-
-defmodule Geometria do
-  def oblast({:obdlznik, w, h}) do
-    w * h
-  end
-
-  def oblast({:kruh, r}) when is_number(r) do
-    3.14 * r * r
-  end
-end
-
-Geometria.oblast({:obdlznik, 2, 3}) #=> 6
-Geometria.oblast({:kruh, 3})       #=> 28.25999999999999801048
-# Geometria.oblast({:kruh, "nie_je_cislo"})
-#=> ** (FunctionClauseError) no function clause matching in Geometria.oblast/1
-
-# Vďaka nemeniteľnosti (immutability) je rekurzia významnou časťou elixiru
-defmodule Rekurzia do
-  def sumuj_zoznam([hlavicka | schvost], acc) do
-    sumuj_zoznam(chvost, acc + hlavicka)
-  end
-
-  def sumuj_zoznam([], acc) do
-    acc
-  end
-end
-
-Rekurzia.sumuj_zoznam([1,2,3], 0) #=> 6
-
-# Elixir moduly podporujú atribúty, existujú vstavané atribúty a takisto
-# môžte pridávať vlastné.
-defmodule MojModul do
-  @moduledoc """
-  Toto je vstavaný atribút v príkladovom module.
-  """
-
-  @moj_udaj 100 # Toto je vlastný atribút.
-  IO.inspect(@moj_udaj) #=> 100
-end
-
-# Pipe operátor (rúra) |> umožnuje predať výsledok výrazu ako prvý parameter
-# do ďalšej funkcie.
-
-Range.new(1,10)
-|> Enum.map(fn x -> x * x end)
-|> Enum.filter(fn x -> rem(x, 2) == 0 end)
-#=> [4, 16, 36, 64, 100]
-
-## ---------------------------
-## -- Štruktúry a výnimky
-## ---------------------------
-
-# Štruktúry sú rozšírenia postavené na mapách, ktoré prinášajú defaultné
-# hodnoty, garancie v čase kompilácie a polymorfizmus do Elixiru.
-defmodule Osoba do
-  defstruct meno: nil, vek: 0, vyska: 0
-end
-
-joe_info = %Osoba{ meno: "Joe", vek: 30, vyska: 180 }
-#=> %Osoba{vek: 30, vyska: 180, meno: "Joe"}
-
-# Prístup k hodnote mena
-joe_info.meno #=> "Joe"
-
-# Zmena hodnoty veku
-starsi_joe_info = %{ joe_info | vek: 31 }
-#=> %Osoba{vek: 31, vyska: 180, meno: "Joe"}
-
-# `try` blok s kľúčovým slovom `rescue` sa používa na riadenie výnimiek
-try do
-  raise "nejaký error"
-rescue
-  RuntimeError -> "zachytí runtime error"
-  _error -> "zachytí ľubovoľný iný error"
-end
-#=> "zachytí runtime error"
-
-# Každá výnimka má správu
-try do
-  raise "nejaký error"
-rescue
-  x in [RuntimeError] ->
-    x.message
-end
-#=> "nejaký error"
-
-## ---------------------------
-## -- Konkurencia
-## ---------------------------
-
-# Elixir sa pri konkurencii spolieha na Actor model. Všetko čo je
-# potrebné na písanie konkuretných programov v elixire sú tri primitívy:
-# spawning procesy, posielanie a prijímanie správ.
-
-# Na spustnenie nového procesu použijeme `spawn` funkciu, ktorá má ako
-# parameter funkciu.
-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
-spawn(f) #=> #PID<0.40.0>
-
-# `spawn` vracia pid (identifikátor procesu), tento pid možno použiť na
-# posielanie správ procesu. Správu pošleme `send` operatorátorom.
-# Aby všetko fungovalo ako má, potrebujeme byť schopný správu prijať. To
-# dosiahneme s `receive` mechanizmom:
-
-# `receive do` blok sa používa na počúvanie správ a ich spracúvavanie v čase
-# prijatia. `receive do` blok spracuje iba jednu prijatú správu. Pre
-# spracovanie viacerých správ, musí funkcia s `receive do` blokom rekurzívne
-# volať samu seba, aby sa dostala opäť do `receive do` bloku.
-
-defmodule Geometria do
-  def slucka_oblasti do
-    receive do
-      {:obdlznik, w, h} ->
-        IO.puts("Oblast = #{w * h}")
-        slucka_oblasti()
-      {:kruh, r} ->
-        IO.puts("Oblast = #{3.14 * r * r}")
-        slucka_oblasti()
-    end
-  end
-end
-
-# Kompiluj modul a vytvor proces, ktorý vyhodnotí `slucka_oblasti` v shelli
-
-pid = spawn(fn -> Geometria.slucka_oblasti() end) #=> #PID<0.40.0>
-# Alternatívne
-pid = spawn(Geometria, :slucka_oblasti, [])
-
-# Pošli správu ku `pid`, ktorá bude v zhode so vzorom v receive časti
-send pid, {:obdlznik, 2, 3}
-#=> Oblast = 6
-#   {:obdlznik,2,3}
-
-send pid, {:kruh, 2}
-#=> Oblast = 12.56000000000000049738
-#   {:kruh,2}
-
-# Shell je takisto proces, môžete použiť `self` pre zistenie aktuálneho pid-u
-self() #=> #PID<0.27.0>
-
-## ---------------------------
-## -- Agenti
-## ---------------------------
-
-# Agent je proces, ktorý udržuje informácie o meniacej sa hodnote
-
-# Vytvor agenta s `Agent.start_link` parametrom, ktorého je funkcia
-# Iniciálny stav agenta bude čokoľvek, čo daná funkcia vráti
-{ok, moj_agent} = Agent.start_link(fn -> ["cervena, zelena"] end)
-
-# `Agent.get` vezme meno agenta a `fn` , ktorej je odovzdaný aktuálny stav
-# Čokoľvek čo `fn` vráti je to, čo dostanete späť
-Agent.get(moj_agent, fn farby -> farby end) #=> ["cervena, "zelena"]
-
-# Zmena stavu agenta rovnakým spôsobom
-Agent.update(moj_agent, fn farby -> ["modra" | farby] end)
-```
-
-## Referencie
-
-* [Začíname](http://elixir-lang.org/getting-started/introduction.html) z
-[Elixir stránky](http://elixir-lang.org)
-* [Elixir dokumentácia](http://elixir-lang.org/docs/master/)
-* [Elixir programovanie](https://pragprog.com/book/elixir/programming-elixir)
- od Dave Thomasa
-* [Elixir ťahák](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
-* [Nauč sa kúsok Erlangu pre veľké dobro!](http://learnyousomeerlang.com/) od
-Freda Heberta
-* [Erlang programovanie: Softvér pre konkurentný svet](https://pragprog
-.com/book/jaerlang2/programming-erlang) od Joe Armstronga