From 12b2f787d6b0c7e1c86772dc2af078060738c13f Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 20 Apr 2016 11:48:18 +0200
Subject: [PATCH 01/13] Update index.html

Added Croatian
---
 web/index.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/web/index.html b/web/index.html
index ff68a4c9..8b094ef1 100644
--- a/web/index.html
+++ b/web/index.html
@@ -17,7 +17,8 @@ <h1>Scala School!</h1>
           <ul style="list-style-type: none;">
           <li><a href="ko/index.html">한국어</a>
           <li><a href="ru/index.html">Русский</a>
-          <li><a href="zh_cn/index.html">简体中文</a></b>
+          <li><a href="zh_cn/index.html">简体中文</a>
+          <li><a href="hr/index.html">Hrvatski</a></b>
           </ul>
 
           <h2>About</h2>

From 8e24a37ef9e408f20460fd1372b9b935e71f2d6c Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 20 Apr 2016 13:26:13 +0200
Subject: [PATCH 02/13] Update default.html

Added Croatian
---
 web/_layouts/default.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/web/_layouts/default.html b/web/_layouts/default.html
index 88797dc4..6b009bae 100644
--- a/web/_layouts/default.html
+++ b/web/_layouts/default.html
@@ -55,7 +55,9 @@
           Chinese simple translation by
           <a href="https://github.com/jasonqu">jasonqu</a>;
           Korean translation by
-          <a href="https://github.com/enshahar">enshahar</a>;<br />
+          <a href="https://github.com/enshahar">enshahar</a>
+          Croatian translation by
+          <a href="https://github.com/boljsa">boljsa</a>;<br />
           <br />
     <div id="footer">
       <div class="inner">

From c24a2db3d56ee971b3cc2b8fa51ba4b299559af9 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 20 Apr 2016 13:29:22 +0200
Subject: [PATCH 03/13] Update post.html

Added Croatian
---
 web/_layouts/post.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/web/_layouts/post.html b/web/_layouts/post.html
index 39ebd55a..c7ef51b4 100644
--- a/web/_layouts/post.html
+++ b/web/_layouts/post.html
@@ -73,7 +73,9 @@ <h3><a href="index.html">{{ page.title }}</a></h3>
           Chinese simple translation by
           <a href="https://github.com/jasonqu">jasonqu</a>;
           Korean translation by
-          <a href="https://github.com/enshahar">enshahar</a>;<br />
+          <a href="https://github.com/enshahar">enshahar</a>
+          Croatian translation by
+          <a href="https://github.com/boljsa">boljsa</a>;<br />
           <br />
 
           Licensed under the <a href="http://www.apache.org/licenses/LICENSE-2.0" target="_blank">Apache License v2.0</a>.

From b9898e5b789b81dff5014a77c6d461ef8ceb3015 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 20 Apr 2016 13:41:03 +0200
Subject: [PATCH 04/13] Create index.html

Added Croatian index.html
---
 web/hr/index.html | 56 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 web/hr/index.html

diff --git a/web/hr/index.html b/web/hr/index.html
new file mode 100644
index 00000000..1889d67b
--- /dev/null
+++ b/web/hr/index.html
@@ -0,0 +1,56 @@
+---
+layout: default
+title: Scala školica
+---
+
+      <div class="hero-unit">
+        <h1>Scala školica!</h1>
+        <p>Od &empty; do Distribuiranog Servisa</p>
+      </div>
+
+      <!-- Example row of columns -->
+      <div class="row">
+        <div class="span8">
+
+          <p><b>Ostali jezici:</b></p>
+                <ul style="list-style-type: none;">
+                <li><a href="../index.html">English</a></li>
+                <li><a href="../ko/index.html">한국어</a>
+                <li><a href="../ru/index.html">Русский</a>
+                <li><a href="../zh_cn/index.html">简体中文</a></b>
+          </ul>
+
+          <h2>Kratki info</h2>
+          <p>Scala škola je započela kao serija lekcija na Twitter-u kako bi pripremila iskusne inženjere da postanu produktivni <a href="http://www.scala-lang.org/">Scala</a> programeri. Scala je relativno novi jezik, ali se temelji na mnogim poznatim konceptima. Zbog toga se pretpostavlja da Vi, draga publiko ;), poznajete osnovne koncepte OOP na kojima se temelji Scala. Na taj način ćete brže svladati osnove Scala programskog jezika.
+          </p>
+
+          <h2>Pristup</h2>
+          <p>Smatramo da je najbolje prići učenju Scale ne kao da se radi o poboljšanoj verziji Jave, nego kao da se radi o potpuno novom jeziku. Iskustvo u Javi se ne očekuje. Fokus će biti na interpreter-u i na objektno-funkcijskom stilu kao i na stilu programiranja. Naglasak će biti na održivosti, jasnoći izraza i utjecaju type sustava.</p>
+          <p>Većina lekcija zahtjeva samo SCALA REPL. Čitatelja se potiče da prati lekcije, ali i da dodatno proširuje svoje znanje o Scali! Koristite ove lekcije kao početnu točku za daljnje istraživanje Scale.</p>
+
+          <h2>Ostalo</h2>
+          <p>Dodatni sadržaji za učenje:
+          <ul>
+          <li><strong><a href="http://twitter.github.com/effectivescala/">Efektivna Scala</a></strong> Twitter "najbolje prakse" za Scalu. Korisno za razumijevanje idioma u Twitter kodu.</li>
+          <li><strong><a href="http://docs.scala-lang.org">scala-lang.org dokumentacija</a></strong> Linkovi do tutoriala, manuala, API reference dokumentacije, knjiga, ...</li>
+          <li><strong><a href="http://www.scala-lang.org/api/">Scala API dokumentacija</a></strong></li>
+          </ul>
+
+        </div>
+        <div class="span6">
+          <h2>Lekcije</h2>
+            <dl>
+              {% for lesson in site.lessons %}
+                <dt><a href="{{ lesson.url }}">{{ lesson.title }}</a></dt>
+                <dd>{{ lesson.desc }}</dd>
+              {% endfor %}
+            </dl>
+       </div>
+      </div>
+    </div> <!-- /container -->
+
+    <!-- banner -->
+    <a href="https://github.com/twitter/scala_school"><img style="position: absolute; top: 0; right: 0; border: 0;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub"></a>
+
+  </body>
+</html>

From 4dfe3ba7ae2d8e0f1a4e562cc0bed0b6e93d8145 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 20 Apr 2016 20:05:17 +0200
Subject: [PATCH 05/13] Update _config.yml

Added Croatian
---
 web/_config.yml | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/web/_config.yml b/web/_config.yml
index f534d6c2..584f59a7 100644
--- a/web/_config.yml
+++ b/web/_config.yml
@@ -5,86 +5,103 @@ lessons:
     title_ko: 기초
     title_ru: Основы
     title_zh_cn: 基础
+    title_hr: Hrvatski
     url: basics.html
     desc: Values, functions, classes, methods, inheritance, try-catch-finally. Expression-oriented programming
     desc_ko: 값, 함수, 클래스, 메소드, 상속, try-catch-finally. 식 중심의 프로그래밍
     desc_ru: Переменные, функции, классы, методы, наследование, try-catch-finally. Программирование ориентированное на выражения
     desc_zh_cn: 值，函数，类，方法，继承，try-catch-finally。面向表达式编程
+    desc_hr: Funkcije, klase, metode, nasljeđivanje, try-catch-finally. Expression-orijentirano programiranje
   -
     title: Basics continued
     title_ko: 기초(계속)
     title_ru: Основы языка. Продолжение
     title_zh_cn: 基础知识（续）
+    title_hr: Nastavak osnova
     url: basics2.html
     desc: Case classes, objects, packages, apply, update, Functions are Objects (uniform access principle), pattern matching.
     desc_ko: 케이스 클래스, 객체, 패키지, apply, update, 함수는 객체이다(동일한 억세스 원칙), 패턴 매치
     desc_ru: Case классы, объекты, пакеты, apply, update, Функции как Объекты (единый принцип доступа), сопоставление с образцом.
     desc_zh_cn: 样本类，对象，包，应用，更新，函数即对象（统一访问原则），模式匹配。
+    desc_hr: Case klase, objekti, paketi, update, Funkcije su Objekti (princip uniformnog pristupa), pattern matchiranje.
   -
     title: Collections
     title_ko: 컬렉션
     title_ru: Коллекции
     title_zh_cn: 集合
+    title_hr: Kolekcije
     url: collections.html
     desc: Lists, Maps, functional combinators (map, foreach, filter, zip, folds)
     desc_ko: 리스트, 맵, 함수 콤비네이터(map, foreach, filter, zip, fold들)
     desc_ru: Списки, Карты, функциональные комбинаторы (map, foreach, filter, zip, folds)
     desc_zh_cn: 列表，映射，功能组合(map, foreach, filter, zip, folds)
+    desc_hr: Liste, Mape, funkcionalni kombinatori (map, foreach, filter, zip, folds)
   -
     title: Pattern matching & functional composition
     title_ko: 패턴 매치와 함수 합성
     title_ru: Сопоставление с образцом и функкциональная композиция
     title_zh_cn: 模式匹配与函数组合
+    title_hr: Pattern matchiranje & funkcionalna kompozicija
     url: pattern-matching-and-functional-composition.html
     desc: More functions! PartialFunctions, more Pattern Matching
     desc_ko: 함수에 대한 추가 설명, 부분함수, 패턴 매치에 대한 설명
     desc_ru: Еще больше функций! Частичные функции, еще больше сопоставления с образцом
     desc_zh_cn: 更多函数！偏函数，更多模式匹配
+    desc_hr: Još funkcija! PartialFunkcije, još Pattern Matchiranja
   -
     title: Type & polymorphism basics
     title_ko: 타입과 다형성의 기초
     title_ru: Основы типов и полиморфизма
     title_zh_cn: 类型和多态基础
+    title_hr: Tipovi & osnove polimorfizma
     url: type-basics.html
     desc: Basic Types and type polymorphism, type inference, variance, bounds, quantification
     desc_ko: 기본 타입, 타입 다형성, 타입 추론, 공변성, 바운드, 한정하기
     desc_ru: Основные типы и полиморфизм типов, вывод типов, изменчивость, пределы, квантификация
     desc_zh_cn: 基本类型和类型多态性，类型推断，变性，边界，量化
+    desc_hr: Osnovni Tipovi i tipovi polimorfizma, nasljeđivanje tipova, variance, bounds, kvantifikacija
   -
     title: Advanced types
     title_ko: 타입(고급 주제)
     title_ru: Дополнительные типы
     title_zh_cn: 高级类型
+    title_hr: Napredni tipovi
     url: advanced-types.html
     desc: Advanced Types, view bounds, higher-kinded types, recursive types, structural types
     desc_ko: 타입에 대한 추가 설명, 뷰 바운드, 상류 타입, 재귀적 타입, 구조적 타입
     desc_ru: Дополнительные типы, видимое ограничение, типы высшего порядка, рекурсивные типы, структурные типы
     desc_zh_cn: 高级类型，视界，更高级多态性类型，递归类型，结构类型
+    desc_hr: Napredni Tipovi, pregled bounds-a, higher-kinded tipovi, rekurzivni tipovi, strukturalni tipovi
   -
     title: Simple Build Tool
     title_ko: SBT
     title_ru: Simple Build Tool
     title_zh_cn: 简单构建工具
+    title_hr: Simple Build Tool
     url: sbt.html
     desc: All about SBT, the standard Scala build tool
     desc_ko: 표준 스칼라 빌드 도구인 SBT에 대한 설명
     desc_ru: Все о SBT, Стандартное средство сборки приложений для Scala
     desc_zh_cn: 关于SBT——标准的Scala构建工具
+    desc_hr: Sve o SBT-u, standardni Scala build tool
   -
     title: More collections
     title_ko: 컬렉션(계속)
     title_ru: Подробнее о коллекциях
     title_zh_cn: 更多的集合
+    title_hr: Još kolekcija
     url: coll2.html
     desc: Tour of the Scala Collections library
     desc_ko: 스칼라 컬렉션 라이브러리 소개
     desc_ru: Рассказ о библиотеке коллекций Scala
     desc_zh_cn: Scala Collections库指南
+    desc_hr: Tura kroz Scala Collections biblioteku
   -
     title: Testing with specs
     title_ko: specs로 테스트하기
     title_ru: Тестирование с помощью specs
     title_zh_cn: 使用specs测试
+    title_hr: Testiranje sa speckom
     url: specs.html
     desc_ko: Scala 테스트 프레임워크 Specs로 테스트하기
     desc_ru: Написание тестов с помощью Specs, Scala BDD фреймфорк для тестирования
@@ -93,39 +110,47 @@ lessons:
     title_ko: 스칼라의 동시성
     title_ru: Параллельность в Scala
     title_zh_cn: Scala 并发编程
+    title_hr: Konkurentnost u Scali
     url: concurrency.html
     desc: Runnable, Callable, threads, Futures
     desc_ko: Runnable, Callable, 쓰레드, Future
     desc_ru: Runnable, Callable, потоки, Futures
     desc_zh_cn: Runnable, Callable, 线程, Futures
+    desc_hr: Runnable, Callable, dretve, Futures
   -
     title: Java + Scala
     title_ko: Java + Scala
     title_ru: Java + Scala
     title_zh_cn: Java + Scala
+    title_hr: Java + Scala
     url: java.html
     desc: 'Java interop: Using Scala from Java'
     desc_ko: '자바에서 스칼라 사용하기'
     desc_ru:  'Java совместимость: Использование Scala из Java'
     desc_zh_cn:  'Java跨平台交互：在Java中使用Scala'
+    desc_hr: 'Java interoperabilnost: Korištenje Scale iz Jave'
   -
     title: An introduction to Finagle
     title_ko: 피네이글(Finagle) 소개
     title_ru: Введение в Finagle
     title_zh_cn: Finagle介绍
+    title_hr: Uvod u Finagle
     url: finagle.html
     desc: 'Finagle primitives: Future, Service, Filter, Builder'
     desc_ko: '피네이글 기본 요소: Future, Servie, Filter, Builder'
     desc_ru: 'Finagle примитивы: Future, Service, Filter, Builder'
     desc_zh_cn: 'Finagle原语：Future, Service, Filter, Builder'
+    desc_hr: 'Finagle primitivi: Future, Service, Filter, Builder'
   -
     title: Searchbird
     title_ko: 검색조(Searchbird)
     title_ru: Searchbird
     title_zh_cn: Searchbird
+    title_hr: Searchbird
     url: searchbird.html
     desc: Building a distributed search engine using Finagle
     desc_ko: 피네이글로 분산 검색 엔진 만들기
     desc_ru: Создание распределенного поискового движка, используя Finagle
     desc_zh_cn: 利用Finagle构建一个分布式搜索引擎
+    desc_hr: Kreiranje distribuiranog algoritma pretraživanja koristeći Finagle
 

From bf9eac174be7c95fb0ab861d72382445aec38d22 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Mon, 25 Apr 2016 12:42:16 +0200
Subject: [PATCH 06/13] Corrected hr sections in _config.yml; added missing ;
 sign in default.html & post.html layouts; added hr advanced-types.textile

---
 web/_config.yml               |  10 +-
 web/_layouts/default.html     |   2 +-
 web/_layouts/post.html        |   2 +-
 web/hr/advanced-types.textile | 413 ++++++++++++++++++++++++++++++++++
 4 files changed, 420 insertions(+), 7 deletions(-)
 create mode 100644 web/hr/advanced-types.textile

diff --git a/web/_config.yml b/web/_config.yml
index 584f59a7..bd16e9ac 100644
--- a/web/_config.yml
+++ b/web/_config.yml
@@ -5,7 +5,7 @@ lessons:
     title_ko: 기초
     title_ru: Основы
     title_zh_cn: 基础
-    title_hr: Hrvatski
+    title_hr: Osnove
     url: basics.html
     desc: Values, functions, classes, methods, inheritance, try-catch-finally. Expression-oriented programming
     desc_ko: 값, 함수, 클래스, 메소드, 상속, try-catch-finally. 식 중심의 프로그래밍
@@ -23,7 +23,7 @@ lessons:
     desc_ko: 케이스 클래스, 객체, 패키지, apply, update, 함수는 객체이다(동일한 억세스 원칙), 패턴 매치
     desc_ru: Case классы, объекты, пакеты, apply, update, Функции как Объекты (единый принцип доступа), сопоставление с образцом.
     desc_zh_cn: 样本类，对象，包，应用，更新，函数即对象（统一访问原则），模式匹配。
-    desc_hr: Case klase, objekti, paketi, update, Funkcije su Objekti (princip uniformnog pristupa), pattern matchiranje.
+    desc_hr: Case klase, objekti, paketi, update, Funkcije su Objekti (princip uniformnog pristupa), pattern match-iranje.
   -
     title: Collections
     title_ko: 컬렉션
@@ -47,7 +47,7 @@ lessons:
     desc_ko: 함수에 대한 추가 설명, 부분함수, 패턴 매치에 대한 설명
     desc_ru: Еще больше функций! Частичные функции, еще больше сопоставления с образцом
     desc_zh_cn: 更多函数！偏函数，更多模式匹配
-    desc_hr: Još funkcija! PartialFunkcije, još Pattern Matchiranja
+    desc_hr: Još funkcija! Partial Funkcije, još Pattern Match-iranja
   -
     title: Type & polymorphism basics
     title_ko: 타입과 다형성의 기초
@@ -59,7 +59,7 @@ lessons:
     desc_ko: 기본 타입, 타입 다형성, 타입 추론, 공변성, 바운드, 한정하기
     desc_ru: Основные типы и полиморфизм типов, вывод типов, изменчивость, пределы, квантификация
     desc_zh_cn: 基本类型和类型多态性，类型推断，变性，边界，量化
-    desc_hr: Osnovni Tipovi i tipovi polimorfizma, nasljeđivanje tipova, variance, bounds, kvantifikacija
+    desc_hr: Osnovni Tipovi i tipovi polimorfizma, nasljeđivanje tipova, variance, granice, kvantifikacija
   -
     title: Advanced types
     title_ko: 타입(고급 주제)
@@ -71,7 +71,7 @@ lessons:
     desc_ko: 타입에 대한 추가 설명, 뷰 바운드, 상류 타입, 재귀적 타입, 구조적 타입
     desc_ru: Дополнительные типы, видимое ограничение, типы высшего порядка, рекурсивные типы, структурные типы
     desc_zh_cn: 高级类型，视界，更高级多态性类型，递归类型，结构类型
-    desc_hr: Napredni Tipovi, pregled bounds-a, higher-kinded tipovi, rekurzivni tipovi, strukturalni tipovi
+    desc_hr: Napredni Tipovi, pregled granica, higher-kinded tipovi, rekurzivni tipovi, strukturalni tipovi
   -
     title: Simple Build Tool
     title_ko: SBT
diff --git a/web/_layouts/default.html b/web/_layouts/default.html
index 6b009bae..3c0d8db2 100644
--- a/web/_layouts/default.html
+++ b/web/_layouts/default.html
@@ -55,7 +55,7 @@
           Chinese simple translation by
           <a href="https://github.com/jasonqu">jasonqu</a>;
           Korean translation by
-          <a href="https://github.com/enshahar">enshahar</a>
+          <a href="https://github.com/enshahar">enshahar</a>;
           Croatian translation by
           <a href="https://github.com/boljsa">boljsa</a>;<br />
           <br />
diff --git a/web/_layouts/post.html b/web/_layouts/post.html
index c7ef51b4..e3c312b0 100644
--- a/web/_layouts/post.html
+++ b/web/_layouts/post.html
@@ -73,7 +73,7 @@ <h3><a href="index.html">{{ page.title }}</a></h3>
           Chinese simple translation by
           <a href="https://github.com/jasonqu">jasonqu</a>;
           Korean translation by
-          <a href="https://github.com/enshahar">enshahar</a>
+          <a href="https://github.com/enshahar">enshahar</a>;
           Croatian translation by
           <a href="https://github.com/boljsa">boljsa</a>;<br />
           <br />
diff --git a/web/hr/advanced-types.textile b/web/hr/advanced-types.textile
new file mode 100644
index 00000000..ee918053
--- /dev/null
+++ b/web/hr/advanced-types.textile
@@ -0,0 +1,413 @@
+---
+prev: type-basics.textile
+next: sbt.textile
+title: Napredni tipovi
+layout: post
+---
+
+Ova lekcija sadržava sljedeće teme:
+
+* "Pregled granica":#viewbounds ("tipovi klasa")
+* "Drugi tipovi granica":#otherbounds
+* "Higher kinded tipovi & ad-hoc polimorfizam":#higher
+* "F-bounded polimorfizam / rekurzivni tipovi":#fbounded
+* "Strukturalni tipovi":#structural
+* "Abstraktni tipovi":#abstractmem
+* "Tipovi brisanja & manifest":#manifest
+* "Case studija: Finagle":#finagle
+
+h2(#viewbounds). Pregled granica ("tipovi klasa")
+
+Ponekad ne morate definirati da je jedan tip jednak/inferioran/nadmoćan prema drugome, samo da bi ga mogli fake-ati sa konverzijama. Pregled granica specificira tip koji može biti "kao" neki drugi tip. Ovo ima smisla za operacije kod kojih je potrebno čitati objekte ali ne i mijenjati ih.
+
+*Implicitne* funkcije dopuštaju automatsku konverziju. Preciznije, one dopuštaju on-demand funkciju kada to može pomoći zadovoljiti type inference. e.g.:
+
+<pre>
+scala> implicit def strToInt(x: String) = x.toInt
+strToInt: (x: String)Int
+
+scala> "123"
+res0: java.lang.String = 123
+
+scala> val y: Int = "123"
+y: Int = 123
+
+scala> math.max("123", 111)
+res1: Int = 123
+</pre>
+
+Za tip granice koji zahtjeva da funkcija postoji za dani tip možete definirati pregled granice sa <code><%</code> npr.
+
+<pre>
+scala> class Container[A <% Int] { def addIt(x: A) = 123 + x }
+defined class Container
+</pre>
+
+Ovo govori da *A* mora biti vidljiv kao *Int*. Pa hajDm0 probati:
+
+<pre>
+scala> (new Container[String]).addIt("123")
+res11: Int = 246
+
+scala> (new Container[Int]).addIt(123)
+res12: Int = 246
+
+scala> (new Container[Float]).addIt(123.2F)
+<console>:8: error: could not find implicit value for evidence parameter of type (Float) => Int
+       (new Container[Float]).addIt(123.2)
+        ^
+</pre>
+
+h2(#otherbounds). Ostali tipovi granica
+
+Metode mogu primijeniti još složenije tipove granica kroz implicitne parametre. Npr. <code>List</code> podržava <code>sum</code> na numeričkom sadržaju ali ne i na drugom tipu sadržaja. Svi Scala numerički tipovi ne dijele nadklase pa za to ne možemo samo reći <code>T <: Number</code>. Umjesto toga, Scala math biblioteka <a href="http://www.azavea.com/blogs/labs/2011/06/scalas-numeric-type-class-pt-1/"> definira implicitni tip <code>Numeric[T]</code> za prikladan T</a> tip. Zatim ga <code>List</code> definicija koristi:
+
+<pre>
+sum[B >: A](implicit num: Numeric[B]): B
+</pre>
+
+Ako pozovete <code>List(1,2).sum()</code>, ne morate proslijediti _num_ parameter; on je postavljen implicitno. Ali ako pozovete <code>List("whoop").sum()</code>, iz nekog razloga se žali da ne može postaviti <code>num</code>.
+
+Metode mogu pitati za neku vrstu specifičnog "dokaza" za tip bez postavljanja čudnih objekata kao <code>Numeric</code>. Umjesto toga, možete koristiti jedan od ovih type-relation operatora:
+
+|A =:= B|A must be equal to B|
+|A <:< B|A must be a subtype of B|
+|A <%< B|A must be viewable as B|
+
+(Ako dobijete pogreške pokušavajući koristiti <:< ili <%<, znajte da toga više nema u Scali 2.10. Bye, bye, nema više. Primjeri Scala Školice rade sa "Scalom 2.9.x":http://www.scala-lang.org/download/2.9.3.html Možete koristiti noviju verziju Scale, ali očekujte pogreške.
+
+<pre>
+scala> class Container[A](value: A) { def addIt(implicit evidence: A =:= Int) = 123 + value }
+defined class Container
+
+scala> (new Container(123)).addIt
+res11: Int = 246
+
+scala> (new Container("123")).addIt
+<console>:10: error: could not find implicit value for parameter evidence: =:=[java.lang.String,Int]
+</pre>
+
+Slično, gledajući naš prijašnji implicit, možemo napraviti sljedeće:
+
+<pre>
+scala> class Container[A](value: A) { def addIt(implicit evidence: A <%< Int) = 123 + value }
+defined class Container
+
+scala> (new Container("123")).addIt
+res15: Int = 246
+</pre>
+
+h3. Generičko programiranje sa view-ima
+
+In da Scala standard library, view-si se primarno koriste za implementaciju generičkih funkcija naspram kolekcija.
+Npr. "min" funkcija (nad *Seq[]*), koristi ovu tehniku:
+
+<pre>
+def min[B >: A](implicit cmp: Ordering[B]): A = {
+  if (isEmpty)
+    throw new UnsupportedOperationException("empty.min")
+
+  reduceLeft((x, y) => if (cmp.lteq(x, y)) x else y)
+}
+</pre>
+
+Glavne prednosti ovoga su:
+
+* Item-si u kolekcijama nisu potrebni za implementaciju *Ordered*, ali *Ordered* se koristi kao statičko type check-iranje.
+* Možete definirati svoje vlastito order-iranje bez dodatne podrške biblioteka:
+
+<pre>
+scala> List(1,2,3,4).min
+res0: Int = 1
+
+scala> List(1,2,3,4).min(new Ordering[Int] { def compare(a: Int, b: Int) = b compare a })
+res3: Int = 4
+</pre>
+
+Kao napomena, postoje view-si u standardnom library-u koji prevode *Ordered* u *Ordering* (i obrnuto).
+
+<pre>
+trait LowPriorityOrderingImplicits {
+  implicit def ordered[A <: Ordered[A]]: Ordering[A] = new Ordering[A] {
+    def compare(x: A, y: A) = x.compare(y)
+  }
+}
+</pre>
+
+h4. Kontekst granica & implicitly[]
+
+U Scali 2.8 uvedena je kratica za thread-ing pristupne implicitne argumente.
+
+<pre>
+scala> def foo[A](implicit x: Ordered[A]) {}
+foo: [A](implicit x: Ordered[A])Unit
+
+scala> def foo[A : Ordered] {}
+foo: [A](implicit evidence$1: Ordered[A])Unit
+</pre>
+
+Implicitnim vrijednostima se može pristupiti putem *implicitly*
+
+<pre>
+scala> implicitly[Ordering[Int]]
+res37: Ordering[Int] = scala.math.Ordering$Int$@3a9291cf
+</pre>
+
+Kombinirano, ovo obično rezultira sa sažimanjem koda (less code), pogotovo kada se thread-a kroz view-se.
+
+h2(#higher). Higher-kinded tipovi & ad-hoc polimorfizam
+
+Scala može abstraktirati (ajme koji prijevod) iznad "higher kinded" tipova. Npr. pretpostavimo da morate koristiti nekoliko tipova kontenjera (ali ne onih za odlaganje otpada...) za više tipova podataka. Možete definirati <code>Container</code> interface koji može biti implementiran kao <code>Option</code>, <code>List</code> itd. Želite definirati interface za korištenje određenih vrijednosti u tim kontenjerima bez "zaključavanja" vrijednosnih (value) tipova.
+
+Ovo je analogno funkcijskom čišćenju (kao da se funkcija more analogno očistiti, prije digitalno...lala). Npr. gdje "unarni tip" ima konstruktore <code>List[A]</code>, što znači da moramo zadovoljiti jednu "razinu" tipova varijabli kako bi kreirali konkretni tip (baš kao što "prljava" funkcija treba biti opskrbljena samo jednom listom argumenata kako bi bila pozvana), higher-kinded tip treba više, naravno, zato jer je higher-kinded pa je zahtjevan.
+
+<pre>
+scala> trait Container[M[_]] { def put[A](x: A): M[A]; def get[A](m: M[A]): A }
+
+scala> val container = new Container[List] { def put[A](x: A) = List(x); def get[A](m: List[A]) = m.head }
+container: java.lang.Object with Container[List] = $anon$1@7c8e3f75
+
+scala> container.put("hey")
+res24: List[java.lang.String] = List(hey)
+
+scala> container.put(123)
+res25: List[Int] = List(123)
+</pre>
+
+Napomena da je *Container* "polimorf" u parametriziranom tipu ("container type").
+
+Ako kombiniramo kontenjere sa implicitima, dobijemo "ad-hoc" polimorfizam: mogućnost pisanja generičkih funkcija preko kontenjera.
+
+<pre>
+scala> trait Container[M[_]] { def put[A](x: A): M[A]; def get[A](m: M[A]): A }
+
+scala> implicit val listContainer = new Container[List] { def put[A](x: A) = List(x); def get[A](m: List[A]) = m.head }
+
+scala> implicit val optionContainer = new Container[Some] { def put[A](x: A) = Some(x); def get[A](m: Some[A]) = m.get }
+
+scala> def tupleize[M[_]: Container, A, B](fst: M[A], snd: M[B]) = {
+     | val c = implicitly[Container[M]]
+     | c.put(c.get(fst), c.get(snd))
+     | }
+tupleize: [M[_],A,B](fst: M[A],snd: M[B])(implicit evidence$1: Container[M])M[(A, B)]
+
+scala> tupleize(Some(1), Some(2))
+res33: Some[(Int, Int)] = Some((1,2))
+
+scala> tupleize(List(1), List(2))
+res34: List[(Int, Int)] = List((1,2))
+</pre>
+
+h2(#fbounded). F-bounded polimorfizam
+
+Često je potrebno pristupiti određenoj podklasi u (generičkom) trait-u. Npr. zamislite da imate neki trait koji je generički, ali može biti uspoređivan sa određenom podkalsom tog trait-a.
+
+<pre>
+trait Container extends Ordered[Container]
+</pre>
+
+To zahtjeva od podklase da implementira compare metodu
+
+<pre>
+def compare(that: Container): Int
+</pre>
+
+I zato ne možemo pristupiti konkretnom podtipu, npr.:
+
+<pre>
+class MyContainer extends Container {
+  def compare(that: MyContainer): Int
+}
+</pre>
+
+jer se ne može kompajlirati, budući da smo definirali Ordered za *Container*, a ne određeni podtip.
+
+Alternativno rješenje bi bilo parametrizirati Container tako da možemo pristupiti podtipu u podklasi.
+
+<pre>
+trait Container[A] extends Ordered[A]
+</pre>
+
+Podklasa sada može:
+
+<pre>
+class MyContainer extends Container[MyContainer] {
+  def compare(that: MyContainer): Int
+}
+</pre>
+
+Ali problem je da tip A nije ograničen ničime i potencijalno možete napraviti:
+
+<pre>
+class MyContainer extends Container[String] {
+  def compare(that: String): Int
+}
+</pre>
+
+Kako bi to izbjegli koristimo F-bounded polimorfizam.
+
+<pre>
+trait Container[A <: Container[A]] extends Ordered[A]
+</pre>
+
+Čudan tip! Ali primijetite da je Ordered parametriziran na *A*, koji je sam *Container[A]*
+
+Sada:
+
+<pre>
+class MyContainer extends Container[MyContainer] {
+  def compare(that: MyContainer) = 0
+}
+</pre>
+
+Sada su posloženi:
+
+<pre>
+scala> List(new MyContainer, new MyContainer, new MyContainer)
+res3: List[MyContainer] = List(MyContainer@30f02a6d, MyContainer@67717334, MyContainer@49428ffa)
+
+scala> List(new MyContainer, new MyContainer, new MyContainer).min
+res4: MyContainer = MyContainer@33dfeb30
+</pre>
+
+Budući da su svi podtipovi *Container[_]*, možemo definirati drugu podklasu & kreirati miješanu (ali ne pizzu) listu *Container[_]*:
+
+<pre>
+scala> class YourContainer extends Container[YourContainer] { def compare(that: YourContainer) = 0 }
+defined class YourContainer
+
+scala> List(new MyContainer, new MyContainer, new MyContainer, new YourContainer)
+res2: List[Container[_ >: YourContainer with MyContainer <: Container[_ >: YourContainer with MyContainer <: ScalaObject]]]
+  = List(MyContainer@3be5d207, MyContainer@6d3fe849, MyContainer@7eab48a7, YourContainer@1f2f0ce9)
+</pre>
+
+Primijetite kako je tip rezultata sada ograničen sa *YourContainer with MyContainer*. Ovo je rad type inferencer-a. Zanimljivo- ovaj tip ne mora imati smisla, on samo pruža logički viši-niži graničnik (jeste se malo izgubili, viši, niži, dajte se odlučite) za unificirani tip liste. Što se događa ako pokušamo koristiti *Ordered*?
+
+<pre>
+(new MyContainer, new MyContainer, new MyContainer, new YourContainer).min
+<console>:9: error: could not find implicit value for parameter cmp:
+  Ordering[Container[_ >: YourContainer with MyContainer <: Container[_ >: YourContainer with MyContainer <: ScalaObject]]]
+</pre>
+
+Ne postoji *Ordered[]* za unificirani tip. Šteta.
+
+h2(#structural). Strukturalni tipovi
+
+Scala ima podršku za strukturalne tipove* -- zahtjevi tipa su izraženi sa interface _structure_ naspram konkretnog tipa.
+
+<pre>
+scala> def foo(x: { def get: Int }) = 123 + x.get
+foo: (x: AnyRef{def get: Int})Int
+
+scala> foo(new { def get = 10 })
+res0: Int = 133
+</pre>
+
+Ovo može biti korisno u mnogim situacijama, ali implementacija koristi refleksiju, zato budite performance-aware!
+
+h2(#abstractmem). Abstraktni tipovi članova
+
+U trait-u, možete ostaviti type članove abstraktnima.
+
+<pre>
+scala> trait Foo { type A; val x: A; def getX: A = x }
+defined trait Foo
+
+scala> (new Foo { type A = Int; val x = 123 }).getX
+res3: Int = 123
+
+scala> (new Foo { type A = String; val x = "hey" }).getX
+res4: java.lang.String = hey
+</pre>
+
+To je koristan trik kada radite dependency injection itd.
+
+Možete se referencirati prema abstraktnom tipu varijable koristeći hash operator:
+
+<pre>
+scala> trait Foo[M[_]] { type t[A] = M[A] }
+defined trait Foo
+
+scala> val x: Foo[List]#t[Int] = List(1)
+x: List[Int] = List(1)
+</pre>
+
+
+h2(#manifest). Tipovi brisanja & manifesti
+
+Koliko je nama poznato, tip informacije je izgubljen na compile time-u zbog _erasure_. Scala ima *Manifests*, što nam dopušta selektivno vraćanje tipa informacija. Manifesti su implicitne vrijednosti, generirani od strane kompajlera prema potrebi.
+
+<pre>
+scala> class MakeFoo[A](implicit manifest: Manifest[A]) { def make: A = manifest.erasure.newInstance.asInstanceOf[A] }
+
+scala> (new MakeFoo[String]).make
+res10: String = ""
+</pre>
+
+h2(#finagle). Case studija: Finagle
+
+Pogledajte: "https://github.com/twitter/finagle":https://github.com/twitter/finagle
+
+<pre>
+trait Service[-Req, +Rep] extends (Req => Future[Rep])
+
+trait Filter[-ReqIn, +RepOut, +ReqOut, -RepIn]
+  extends ((ReqIn, Service[ReqOut, RepIn]) => Future[RepOut])
+{
+  def andThen[Req2, Rep2](next: Filter[ReqOut, RepIn, Req2, Rep2]) =
+    new Filter[ReqIn, RepOut, Req2, Rep2] {
+      def apply(request: ReqIn, service: Service[Req2, Rep2]) = {
+        Filter.this.apply(request, new Service[ReqOut, RepIn] {
+          def apply(request: ReqOut): Future[RepIn] = next(request, service)
+          override def release() = service.release()
+          override def isAvailable = service.isAvailable
+        })
+      }
+    }
+
+  def andThen(service: Service[ReqOut, RepIn]) = new Service[ReqIn, RepOut] {
+    private[this] val refcounted = new RefcountedService(service)
+
+    def apply(request: ReqIn) = Filter.this.apply(request, refcounted)
+    override def release() = refcounted.release()
+    override def isAvailable = refcounted.isAvailable
+  }
+}
+</pre>
+
+Servis može autorizirati zahtjeve putem filtera.
+
+<pre>
+trait RequestWithCredentials extends Request {
+  def credentials: Credentials
+}
+
+class CredentialsFilter(credentialsParser: CredentialsParser)
+  extends Filter[Request, Response, RequestWithCredentials, Response]
+{
+  def apply(request: Request, service: Service[RequestWithCredentials, Response]): Future[Response] = {
+    val requestWithCredentials = new RequestWrapper with RequestWithCredentials {
+      val underlying = request
+      val credentials = credentialsParser(request) getOrElse NullCredentials
+    }
+
+    service(requestWithCredentials)
+  }
+}
+</pre>
+
+Primijetite kako pozadinski servis zahtjeva autorizirani zahtjev i da je to statički verificirano. Filteri stoga mogu biti smatrani kao servis transformeri. Transformer...
+
+Mnogi filteri se mogu koristiti zajedno:
+
+<pre>
+val upFilter =
+  logTransaction     andThen
+  handleExceptions   andThen
+  extractCredentials andThen
+  homeUser           andThen
+  authenticate       andThen
+  route
+</pre>
+
+Tipkajte sigurno (Type safely)!

From 3c4a8b6c5c3bd75be0264309fbae3cd90207b56e Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Tue, 26 Apr 2016 15:29:41 +0200
Subject: [PATCH 07/13] Added Croatian basics.textile; Corrections in
 advanced-types.textile

---
 web/hr/advanced-types.textile |   4 +-
 web/hr/basics.textile         | 437 ++++++++++++++++++++++++++++++++++
 2 files changed, 439 insertions(+), 2 deletions(-)
 create mode 100644 web/hr/basics.textile

diff --git a/web/hr/advanced-types.textile b/web/hr/advanced-types.textile
index ee918053..b07cebd3 100644
--- a/web/hr/advanced-types.textile
+++ b/web/hr/advanced-types.textile
@@ -74,7 +74,7 @@ Metode mogu pitati za neku vrstu specifičnog "dokaza" za tip bez postavljanja 
 |A <:< B|A must be a subtype of B|
 |A <%< B|A must be viewable as B|
 
-(Ako dobijete pogreške pokušavajući koristiti <:< ili <%<, znajte da toga više nema u Scali 2.10. Bye, bye, nema više. Primjeri Scala Školice rade sa "Scalom 2.9.x":http://www.scala-lang.org/download/2.9.3.html Možete koristiti noviju verziju Scale, ali očekujte pogreške.
+Ako dobijete pogreške pokušavajući koristiti <:< ili <%<, znajte da toga više nema u Scali 2.10. Bye, bye, nema više. Primjeri Scala Školice rade sa "Scalom 2.9.x":http://www.scala-lang.org/download/2.9.3.html Možete koristiti noviju verziju Scale, ali očekujte pogreške.
 
 <pre>
 scala> class Container[A](value: A) { def addIt(implicit evidence: A =:= Int) = 123 + value }
@@ -200,7 +200,7 @@ res34: List[(Int, Int)] = List((1,2))
 
 h2(#fbounded). F-bounded polimorfizam
 
-Često je potrebno pristupiti određenoj podklasi u (generičkom) trait-u. Npr. zamislite da imate neki trait koji je generički, ali može biti uspoređivan sa određenom podkalsom tog trait-a.
+Često je potrebno pristupiti određenoj podklasi u (generičkom) trait-u. Npr. zamislite da imate neki trait koji je generički, ali može biti uspoređivan sa određenom podklasom tog trait-a.
 
 <pre>
 trait Container extends Ordered[Container]
diff --git a/web/hr/basics.textile b/web/hr/basics.textile
new file mode 100644
index 00000000..c143f216
--- /dev/null
+++ b/web/hr/basics.textile
@@ -0,0 +1,437 @@
+---
+layout: post
+title: Osnove
+next: basics2.textile
+---
+
+Ova lekcija sadržava:
+* "O ovoj lekciji":#overview
+* "expressions":#expressions
+* "values":#val
+* "funkcije":#functions
+* "klase":#class
+* "osnovno nasljeđivanje":#extends
+* "trait-ovi":#trait
+* "tipovi":#types
+
+h2(#overview). O ovoj lekciji
+
+U nekoliko prvih tjedana proći ćemo kroz osnovne koncepte i sintaksu, zatim ćemo proširivati znanje koristeći primjere.
+
+Neki primjeri će biti u obliku izvornog koda, dok će drugi biti pisani u obliku interpretera, za svakog ponešto, lalal
+
+Preporučamo da imate dostupan interpreter, to će vam olakšati baratanje primjerima, yeah.
+
+h3. Zašto Scala?
+
+* Ekspresivan
+** Funkcije prvog reda (first-class functions)
+** Closures
+* Sažet
+** Type inference
+** Dosljedna sintaksa za kreiranje funkcija
+* Java interoperabilinost
+** Mogućnost iskorištavanja Java biblioteka
+** Mogućnost iskorištavanja Java alata
+** Bez penala što se tiče performansi
+
+h3. Kako sa Scala-om?
+
+* Kompajlira se u Java bytecode
+* Radi sa standardnim JVM-om
+** I čak sa nekim nestandardnim JVM-ima kao što je Dalvik
+** Scala kompajler je napisao lik koji je autor Java kompajlera, idesh
+
+h3. Misli kao Scalaš
+
+Scala nije samo ljepša Java. Trebate ju učiti otvorenog uma, tak je bolje, vjerujte nam na riječ, časna pionirska.
+
+h3. Daj mi Scalu
+
+Primjeri Scala školice rade sa "Scala 2.9.x":http://www.scala-lang.org/download/2.9.3.html
+Ako koristite Scalu 2.10.x ili noviju, _većina_ primjera će raditi ali ne svi, sori, takav je život.
+
+h3. Pokrenimo Interpreter
+
+Pokrenite <code>sbt console</code>.
+
+<pre>
+$ sbt console
+
+[...]
+
+Welcome to Scala version 2.8.0.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_20).
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala>
+</pre>
+
+
+h2(#expressions). Expressions
+
+<pre>
+scala> 1 + 1
+res0: Int = 2
+</pre>
+
+res0 je automatski kreirana vrijednost koju je izdao interpreter kao rezultat vašeg izraza. res0 je tipa Int i sadrži Integer 2.
+
+Gotovo sve u Scali je izraz.
+
+h2(#val). Values
+
+Rezultatu vašeg izraza možete dati ime, idesh, cool.
+
+<pre>
+scala> val two = 1 + 1
+two: Int = 2
+</pre>
+
+h3. Varijable
+
+Var nam služi za, hm, varijabilne vrijednosti, tko bi rekao, <code>var</code>.
+
+<pre>
+scala> var name = "steve"
+name: java.lang.String = steve
+
+scala> name = "marius"
+name: java.lang.String = marius
+</pre>
+
+h2(#functions). Funkcije
+
+Možete kreirati funkcije pomoću def.
+
+<pre>
+scala> def addOne(m: Int): Int = m + 1
+addOne: (m: Int)Int
+</pre>
+
+U Scali, morate definirati tip potpisa za funkcijske parametre. Interpreter vam vraća type signature dok si rekao keks, keks, keks.
+
+<pre>
+scala> val three = addOne(2)
+three: Int = 3
+</pre>
+
+Funkcije možete ostaviti bez argumenata, neće se ljutiti.
+
+<pre>
+scala> def three() = 1 + 2
+three: ()Int
+
+scala> three()
+res2: Int = 3
+
+scala> three
+res3: Int = 3
+</pre>
+
+h3. Anonimne funkcije
+
+Možete kreirati anonimne funkcije.
+
+<pre>
+scala> (x: Int) => x + 1
+res2: (Int) => Int = <function1>
+</pre>
+
+Ova funkcija dodaje 1 Int-u naziva x.
+
+<pre>
+scala> res2(1)
+res3: Int = 2
+</pre>
+
+Možete proslijeđivati anonimne funkcije ili ih spremiti kao vrijednosti u val.
+
+<pre>
+scala> val addOne = (x: Int) => x + 1
+addOne: (Int) => Int = <function1>
+
+scala> addOne(1)
+res4: Int = 2
+</pre>
+
+Ako se vaša funkcija sastoji od mnoštva izraza, možete koristiti {}
+
+<pre>
+def timesTwo(i: Int): Int = {
+  println("hello world")
+  i * 2
+}
+</pre>
+
+Isto vrijedi i za anonimne funkcije.
+
+<pre>
+scala> { i: Int =>
+  println("hello world")
+  i * 2
+}
+res0: (Int) => Int = <function1>
+</pre>
+
+Primijetiti ćete da se ova sintaksa koristi kada se anonimna funkcija prenosi kao argument.
+
+h3. Partial application
+
+Funkciju možete definirati sa _ znakom, što vam daje drugu funkciju. Scala koristi _ znak sa raznim značenjima i u raznim kontekstima, ali _ možete zamisliti kao neimenovani magični wildcard. U kontekstu <code>{ _ + 2 }</code> znači: neimenovani parametar. Možete ga koristiti kao:
+
+<pre>
+scala> def adder(m: Int, n: Int) = m + n
+adder: (m: Int,n: Int)Int
+</pre>
+
+<pre>
+scala> val add2 = adder(2, _:Int)
+add2: (Int) => Int = <function1>
+
+scala> add2(3)
+res50: Int = 5
+</pre>
+
+Možete djelomično pridružiti bilo koji argument u listi argumenata, ne samo jedan.
+
+h3. Curried funkcije
+
+Ponekad ima smisla dopustiti ljudima pristup pridruživanju nekih argumenata vašim funkcijama sada i ostalim likovima dopustiti to isto nešto kasnije.
+
+Ovdje je primjer funkcije koja vam dopušta napraviti množenje dva broja (back to the elementary school, lalal).
+U jednom pozivu odlučujete koji lik je množitelj (tužitelj) a koji množenik (tuženik).
+
+<pre>
+scala> def multiply(m: Int)(n: Int): Int = m * n
+multiply: (m: Int)(n: Int)Int
+</pre>
+
+Možete pozvati direktno sa oba parametra.
+
+<pre>
+scala> multiply(2)(3)
+res0: Int = 6
+</pre>
+
+Možete popuniti prvi parametar i djelomično pridružiti drugi.
+
+<pre>
+scala> val timesTwo = multiply(2) _
+timesTwo: (Int) => Int = <function1>
+
+scala> timesTwo(3)
+res1: Int = 6
+</pre>
+
+Možete uzeti bilo koju funkciju sa više argumenata i curry-ati ga. Pokušajmo sa <code>adder</code>
+
+<pre>
+scala> val curriedAdd = (adder _).curried
+curriedAdd: Int => (Int => Int) = <function1>
+
+scala> val addTwo = curriedAdd(2)
+addTwo: Int => Int = <function1>
+
+scala> addTwo(4)
+res22: Int = 6
+</pre>
+
+h3. Varijabilna duljina argumenata
+
+Postoji posebna sintaksa za metode koje mogu primati parametre ponavljajućeg tipa. Kako bi primijenili String <code>capitalize</code> funkciju na više stringova, možete napisati:
+
+<pre>
+def capitalizeAll(args: String*) = {
+  args.map { arg =>
+    arg.capitalize
+  }
+}
+
+scala> capitalizeAll("rarity", "applejack")
+res2: Seq[String] = ArrayBuffer(Rarity, Applejack)
+</pre>
+
+h2(#class). Klase
+
+<pre>
+scala> class Calculator {
+     |   val brand: String = "HP"
+     |   def add(m: Int, n: Int): Int = m + n
+     | }
+defined class Calculator
+
+scala> val calc = new Calculator
+calc: Calculator = Calculator@e75a11
+
+scala> calc.add(1, 2)
+res1: Int = 3
+
+scala> calc.brand
+res2: String = "HP"
+</pre>
+
+Prikazani su primjeri u kojima se definiraju metode sa def i polja sa val. Metode su samo funkcije koje mogu pristupati stanjima klase.
+
+h3. Konstruktor
+
+Konstruktori nisu posebne metode, oni su kod koji je van definicije metoda u vašoj klasi. Proširimo naš Calculator primjer kako bi uzeli konstruktor argument i zatim ga iskoristili kako bi inicijalizirali interno stanje.
+
+<pre>
+class Calculator(brand: String) {
+  /**
+   * A constructor.
+   */
+  val color: String = if (brand == "TI") {
+    "blue"
+  } else if (brand == "HP") {
+    "black"
+  } else {
+    "white"
+  }
+
+  // An instance method.
+  def add(m: Int, n: Int): Int = m + n
+}
+</pre>
+
+Primijetite dva različita stila komentara.
+
+Možete koristiti konstruktor kako bi konstruirali instancu:
+
+<pre>
+scala> val calc = new Calculator("HP")
+calc: Calculator = Calculator@1e64cc4d
+
+scala> calc.color
+res0: String = black
+</pre>
+
+h3. Expressions
+
+Naš Calculator primjer prikazuje kako je Scala expression-orijentirana. Boja vrijednosti (value color) je ograničena ovisno o if/else izrazu. Scala je expression-orijentirana: većina stvari su expression-i više nego statement-i.
+
+h3. Funkcije će se potući sa Metodama iliti Functions vs Methods
+
+Funkcije i metode su većinom razmjenjive (interchangeable). Zato jer su funkcije i metode toliko slične, možda niste zapamtili da pozivate <em>thing</em> bez obzira radi li se o funkciji ili metodi. Kada uskočite u dubinu različitosti metoda i funkcija, možda ostanete paf tj. možda vas te razlike zbune, uh.
+
+<pre>
+scala> class C {
+     |   var acc = 0
+     |   def minc = { acc += 1 }
+     |   val finc = { () => acc += 1 }
+     | }
+defined class C
+
+scala> val c = new C
+c: C = C@1af1bd6
+
+scala> c.minc // calls c.minc()
+
+scala> c.finc // returns the function as a value:
+res2: () => Unit = <function0>
+</pre>
+
+Kada zovete jednu "funkciju" bez zagrada ali drugu sa zagradama, možete pomisliti <em>Uppsss, mislio sam da sam znao kako Scala funkcije rade, ali očito šipak, niš od toga. Možda onda ponekad zatrebate zagrade?</em> Možda razumijete funkcije, ali koristite metodu.
+
+U praksi, možete raditi sjajne stvari u Scali ostajući u magli promatrajući razlike između metoda i funkcija. Ako ste novi u Scali i čitate <a href="https://www.google.com/search?q=difference+scala+function+method">explanations of the differences</a>, možda ćete imati problema pratiti razlike. To ne znači da ćete imati problema u korištenju Scale. To samo znači da je razlika između funkcija i metoda jako, jako, prepredena iliti lukava.
+
+h2(#extends). Nasljeđivanje
+
+<pre>
+class ScientificCalculator(brand: String) extends Calculator(brand) {
+  def log(m: Double, base: Double) = math.log(m) / math.log(base)
+}
+</pre>
+
+*Dobro je pogledati* Efektivna Scala pokazuje da je <a href="http://twitter.github.com/effectivescala/#Types%20and%20Generics-Type%20aliases">Type alias</a> bolji od <code>extends</code> kada podklasa nije zapravo različita od nadklase. Tura kroz Scalu opisuje <a href="http://www.scala-lang.org/node/125">Subclassing</a>.
+
+h3. Overloading metode
+
+<pre>
+class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand) {
+  def log(m: Int): Double = log(m, math.exp(1))
+}
+</pre>
+
+h3. Abstraktne klase
+
+Možete definirati <em>abstract class</em>, klasu koja definira neke metode ali ih ne implementira. Podklase extend-aju abstraktne klase i definiraju te metode. Ne možete kreirati instancu abstraktne klase.
+
+<pre>
+scala> abstract class Shape {
+     |   def getArea():Int    // subclass should define this
+     | }
+defined class Shape
+
+scala> class Circle(r: Int) extends Shape {
+     |   def getArea():Int = { r * r * 3 }
+     | }
+defined class Circle
+
+scala> val s = new Shape
+<console>:8: error: class Shape is abstract; cannot be instantiated
+       val s = new Shape
+               ^
+
+scala> val c = new Circle(2)
+c: Circle = Circle@65c0035b
+</pre>
+
+h2(#trait). Traits
+
+<code>traits</code> su kolekcije polja i ponašanja koja možete extend-ati ili miješati sa vašim klasama.
+
+<pre>
+trait Car {
+  val brand: String
+}
+
+trait Shiny {
+  val shineRefraction: Int
+}
+</pre>
+
+<pre>
+class BMW extends Car {
+  val brand = "BMW"
+}
+</pre>
+
+Jedna klasa može extend-ati više trait-ova koristeći <code>with</code> ključnu riječ:
+
+<pre>
+class BMW extends Car with Shiny {
+  val brand = "BMW"
+  val shineRefraction = 12
+}
+</pre>
+
+*Dobro je pogledati* Efektivna Scala ima mišljenja o <a href="http://twitter.github.com/effectivescala/#Object oriented programming-Traits">trait-ovima</a>.
+
+*Kada želite Trait umjesto abstraktne klase?* Ako želite definirati interface-like tip, možda ćete teže izabrati između trait-a i abstraktne klase. Oba vam pružaju mogućnost definiranja tipa sa određenim ponašanjem, pitajući extender-e da definiraju neko drugo ponašanje. Kratke napomene:
+
+<ul>
+<li>Prednosti korištenja trait-ova. Korisno je da klasa može extend-ati više trait-ova; klasa može extend-ati samo jednu klasu.
+<li>Ako trebate konstruktor parametar, koristite abstraktnu klasu. Konstruktori abstraktne klase mogu primati parametre; trait konstruktori ne mogu. Npr. ne možete: <code>trait t(i: Int) {}</code>; <code>i</code> parametar je ilegalan.
+</ul>
+
+Niste prva osoba koja pita ovo pitanje. Vidite pune odgovore na "stackoverflow:Scala traits vs abstract classes":http://stackoverflow.com/questions/1991042/scala-traits-vs-abstract-classes, "Difference between Abstract Class and Trait":http://stackoverflow.com/questions/2005681/difference-between-abstract-class-and-trait i "Programming in Scala: To trait, or not to trait?":http://www.artima.com/pins1ed/traits.html#12.7
+
+h2(#types). Tipovi
+
+Ranije ste vidjeli da smo definirali funkciju koja uzima <code>Int</code> koji je podtip Number tipa. Funkcije također mogu biti generičke i bilo kojeg tipa. Kada se to dogodi, vidjeti ćete type parametar sa square bracket sintaksom. Slijedi primjer:
+
+<pre>
+trait Cache[K, V] {
+  def get(key: K): V
+  def put(key: K, value: V)
+  def delete(key: K)
+}
+</pre>
+
+Metode također mogu imati type parametre.
+
+<pre>
+def remove[K](key: K)
+</pre>

From 768ce9cef02c076eb48cd67a42621f772bb4474b Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 27 Apr 2016 15:27:58 +0200
Subject: [PATCH 08/13] Added Croatian translation of basics2.textile

---
 web/hr/basics2.textile | 330 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 330 insertions(+)
 create mode 100644 web/hr/basics2.textile

diff --git a/web/hr/basics2.textile b/web/hr/basics2.textile
new file mode 100644
index 00000000..7f0895df
--- /dev/null
+++ b/web/hr/basics2.textile
@@ -0,0 +1,330 @@
+---
+prev: basics.textile
+next: collections.textile
+title: Nastavak osnova
+layout: post
+---
+
+Ova lekcija sadržava:
+* "apply":#apply
+* "objekti":#object
+* "Funkcije su Objekti":#fnobj
+* "paketi":#package
+* "pattern matching":#match
+* "case klase":#caseclass
+* "try-catch-finally":#exception
+
+h2(#apply). apply metode
+
+apply metode nam pružaju lijepu sintaksu (syntactic sugar) kada klasa ili objekt ima jednu glavnu svrhu.
+
+<pre>
+scala> class Foo {}
+defined class Foo
+
+scala> object FooMaker {
+     |   def apply() = new Foo
+     | }
+defined module FooMaker
+
+scala> val newFoo = FooMaker()
+newFoo: Foo = Foo@5b83f762
+</pre>
+
+ili
+
+<pre>
+scala> class Bar {
+     |   def apply() = 0
+     | }
+defined class Bar
+
+scala> val bar = new Bar
+bar: Bar = Bar@47711479
+
+scala> bar()
+res8: Int = 0
+</pre>
+
+Ovdje naša instanca objekta izgleda kao da pozivamo metodu. Više o tome kasnije!
+
+h2(#object). Objekti
+
+Objekti se koriste kako bi sadržavali jednu instancu klase.
+
+<pre>
+object Timer {
+  var count = 0
+
+  def currentCount(): Long = {
+    count += 1
+    count
+  }
+}
+</pre>
+
+Kako koristiti
+
+<pre>
+scala> Timer.currentCount()
+res0: Long = 1
+</pre>
+
+Klase i Objekti mogu imati jednako ime. Objekt se zove 'Companion Object'.
+
+SLijedi jednostavan primjer kojemu je jedina svrha ukloniti potrebu korištenja 'new' kako bi kreirali instancu.
+
+<pre>
+class Bar(foo: String)
+
+object Bar {
+  def apply(foo: String) = new Bar(foo)
+}
+</pre>
+
+
+h2(#fnobj). Funkcije su Objekti
+
+U Scali, često pričamo o objektno-funkcionalnom programiranju. Što to znači? Što je zapravo Funkcija?
+
+Funkcija je set trait-ova. Točnije, funkcija koja uzima jedan argument je instanca Function1 trait-a. Ova jtrait definira <code>apply()</code> sintatik šugar koji smo spominjali ranije, dopuštajući vam da pozovete objekt kao što bi zvali funkciju.
+
+<pre>
+scala> object addOne extends Function1[Int, Int] {
+     |   def apply(m: Int): Int = m + 1
+     | }
+defined module addOne
+
+scala> addOne(1)
+res2: Int = 2
+</pre>
+
+Postoji Function0 - 22. Zašto 22? To je magični broj. Nikad nisam trebao funkciju sa više od 22 argumenta.
+
+Sintatički šugar apply-a pomaže ujediniti dualnost objektnog i funkcionalnog programiranja. Možete proslijeđivati klase i koristiti ih kao funkcije jer su funkcije samo instance klasa.
+
+Znači li to da svaki put kada definirate metodu u vašoj klasi, zapravo dobivate instancu Function*? Ne, metode u klasama su metode. Metode su definirane samostalno.
+
+Klase također mogu extend-ati Function i takve instance se mogu pozvati sa ().
+
+<pre>
+scala> class AddOne extends Function1[Int, Int] {
+     |   def apply(m: Int): Int = m + 1
+     | }
+defined class AddOne
+
+scala> val plusOne = new AddOne()
+plusOne: AddOne = <function1>
+
+scala> plusOne(1)
+res0: Int = 2
+</pre>
+
+Lijepi prečac za <code>extends Function1[Int, Int]</code> je <code>extends (Int => Int)</code>
+
+<pre>
+class AddOne extends (Int => Int) {
+  def apply(m: Int): Int = m + 1
+}
+</pre>
+
+h2(#package). Paketi
+
+Možete organizirati vaš kod unutar paketa
+
+<pre>
+package com.twitter.example
+</pre>
+
+na početku datoteke.
+
+Vrijednosti i funkcije ne mogu biti van klase ili objekta. Objekti su koristan alat za organizaciju statičkih funkcija.
+
+<pre>
+package com.twitter.example
+
+object colorHolder {
+  val BLUE = "Blue"
+  val RED = "Red"
+}
+</pre>
+
+Sada možete pristupiti članovima direktno
+
+<pre>
+println("the color is: " + com.twitter.example.colorHolder.BLUE)
+</pre>
+
+Primijetite što Scala repl kaže kada definirate objekt:
+
+<pre>
+scala> object colorHolder {
+     |   val Blue = "Blue"
+     |   val Red = "Red"
+     | }
+defined module colorHolder
+</pre>
+
+Ovo vam daje mali nagovještaj da su dizajneri Scale kreirali objekte kako bi bili dio Scala modul sustava.
+
+h2(#match). Pattern Matching
+
+Jedan od najkorisnijih dijelova Scale.
+
+Match-iranje na vrijednostima
+
+<pre>
+val times = 1
+
+times match {
+  case 1 => "one"
+  case 2 => "two"
+  case _ => "some other number"
+}
+</pre>
+
+Match-iranje sa guard-ovima
+
+<pre>
+times match {
+  case i if i == 1 => "one"
+  case i if i == 2 => "two"
+  case _ => "some other number"
+}
+</pre>
+
+Primijetite kako smo uhvatili vrijednost u varijabli 'i'.
+
+<code>_</code> u zadnjem case izrazu je wildcard; on osigurava da možemo obraditi svaki zahtjev. Inače ćete dobiti runtime error (a to ne želimo, no, no) ako proslijedite broj koji se ne match-ira. Više o tome kasnije.
+
+*Dobro je pogledati* Efektivna Scala ima mišljenje o <a href="http://twitter.github.com/effectivescala/#Functional programming-Pattern matching">when to use pattern matching</a> i <a href="http://twitter.github.com/effectivescala/#Formatting-Pattern matching">pattern matching formatting</a>. Tura kroz Scalu opisuje <a href="http://www.scala-lang.org/node/120">Pattern Matching</a>
+
+h3. Match-iranje na tipovima
+
+Možete koristiti <code>match</code> kako bi obradili vrijednosti različitih tipova na različit način.
+
+<pre>
+def bigger(o: Any): Any = {
+  o match {
+    case i: Int if i < 0 => i - 1
+    case i: Int => i + 1
+    case d: Double if d < 0.0 => d - 0.1
+    case d: Double => d + 0.1
+    case text: String => text + "s"
+  }
+}
+</pre>
+
+h3. Match-iranje na članovima klase
+
+Prisjetimo se našeg Calculator-a iz prijašnjih primjera.
+
+Idemo ga klasificirati prema tipu.
+
+Prvo teži način.
+
+<pre>
+def calcType(calc: Calculator) = calc match {
+  case _ if calc.brand == "HP" && calc.model == "20B" => "financial"
+  case _ if calc.brand == "HP" && calc.model == "48G" => "scientific"
+  case _ if calc.brand == "HP" && calc.model == "30B" => "business"
+  case _ => "unknown"
+}
+</pre>
+
+Idesh, ovo je boljelo. Dobro da Scala pruža lipe alate za ovakve stvari, juhuu.
+
+h2(#caseclass). Case Klase
+
+case klase se koriste kako bi prikladno pohranili i match-irali nad sadržajem klase. Možete ih kreirati bez korištenja new.
+
+<pre>
+scala> case class Calculator(brand: String, model: String)
+defined class Calculator
+
+scala> val hp20b = Calculator("HP", "20b")
+hp20b: Calculator = Calculator(hp,20b)
+
+</pre>
+
+case klase automatski imaju jednakost i lijepu ToString metodu baziranu na argumentima konstruktora.
+
+<pre>
+scala> val hp20b = Calculator("HP", "20b")
+hp20b: Calculator = Calculator(hp,20b)
+
+scala> val hp20B = Calculator("HP", "20b")
+hp20B: Calculator = Calculator(hp,20b)
+
+scala> hp20b == hp20B
+res6: Boolean = true
+</pre>
+
+case klase mogu imati metode baš kao normalne klase.
+
+h6. Case Klase sa pattern match-ingom
+
+case klase su dizajnirane kako bi se koristile sa pattern match-ingom. Pojednostavimo naš calculator klasifikator primjer.
+
+<pre>
+val hp20b = Calculator("HP", "20B")
+val hp30b = Calculator("HP", "30B")
+
+def calcType(calc: Calculator) = calc match {
+  case Calculator("HP", "20B") => "financial"
+  case Calculator("HP", "48G") => "scientific"
+  case Calculator("HP", "30B") => "business"
+  case Calculator(ourBrand, ourModel) => "Calculator: %s %s is of unknown type".format(ourBrand, ourModel)
+}
+</pre>
+
+Druge alternative za zadnji match
+
+<pre>
+  case Calculator(_, _) => "Calculator of unknown type"
+</pre>
+
+  ILI jednostavno možemo ne specificirati da je to Calculator.
+
+<pre>
+  case _ => "Calculator of unknown type"
+</pre>
+
+  ILI možemo napraviti re-bind match-irane vrijednosti sa drugim imenom
+
+<pre>
+  case c@Calculator(_, _) => "Calculator: %s of unknown type".format(c)
+</pre>
+
+h2(#exception). Iznimke
+
+Iznimke su dostupne u Scali kroz try-catch-finally sintaksu koja koristi pattern matching.
+
+<pre>
+try {
+  remoteCalculatorService.add(1, 2)
+} catch {
+  case e: ServerIsDownException => log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
+} finally {
+  remoteCalculatorService.close()
+}
+</pre>
+
+<code>try</code>s su također expression-orijentirane
+
+<pre>
+val result: Int = try {
+  remoteCalculatorService.add(1, 2)
+} catch {
+  case e: ServerIsDownException => {
+    log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
+    0
+  }
+} finally {
+  remoteCalculatorService.close()
+}
+</pre>
+
+Ovo nije primjer odličnog programerskog stila, samo primjer try-catch-finally koji rezultira u expressions-ima kao i većina stvari u Scali.
+
+Finally će se zvati nakon što je iznimka obrađena i nije dio expression-a.

From e82d53adb26eb87caef04a333098686bef835e86 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 27 Apr 2016 15:27:58 +0200
Subject: [PATCH 09/13] Added Croatian translation of basics2.textile

---
 web/hr/basics2.textile | 330 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 330 insertions(+)
 create mode 100644 web/hr/basics2.textile

diff --git a/web/hr/basics2.textile b/web/hr/basics2.textile
new file mode 100644
index 00000000..7f0895df
--- /dev/null
+++ b/web/hr/basics2.textile
@@ -0,0 +1,330 @@
+---
+prev: basics.textile
+next: collections.textile
+title: Nastavak osnova
+layout: post
+---
+
+Ova lekcija sadržava:
+* "apply":#apply
+* "objekti":#object
+* "Funkcije su Objekti":#fnobj
+* "paketi":#package
+* "pattern matching":#match
+* "case klase":#caseclass
+* "try-catch-finally":#exception
+
+h2(#apply). apply metode
+
+apply metode nam pružaju lijepu sintaksu (syntactic sugar) kada klasa ili objekt ima jednu glavnu svrhu.
+
+<pre>
+scala> class Foo {}
+defined class Foo
+
+scala> object FooMaker {
+     |   def apply() = new Foo
+     | }
+defined module FooMaker
+
+scala> val newFoo = FooMaker()
+newFoo: Foo = Foo@5b83f762
+</pre>
+
+ili
+
+<pre>
+scala> class Bar {
+     |   def apply() = 0
+     | }
+defined class Bar
+
+scala> val bar = new Bar
+bar: Bar = Bar@47711479
+
+scala> bar()
+res8: Int = 0
+</pre>
+
+Ovdje naša instanca objekta izgleda kao da pozivamo metodu. Više o tome kasnije!
+
+h2(#object). Objekti
+
+Objekti se koriste kako bi sadržavali jednu instancu klase.
+
+<pre>
+object Timer {
+  var count = 0
+
+  def currentCount(): Long = {
+    count += 1
+    count
+  }
+}
+</pre>
+
+Kako koristiti
+
+<pre>
+scala> Timer.currentCount()
+res0: Long = 1
+</pre>
+
+Klase i Objekti mogu imati jednako ime. Objekt se zove 'Companion Object'.
+
+SLijedi jednostavan primjer kojemu je jedina svrha ukloniti potrebu korištenja 'new' kako bi kreirali instancu.
+
+<pre>
+class Bar(foo: String)
+
+object Bar {
+  def apply(foo: String) = new Bar(foo)
+}
+</pre>
+
+
+h2(#fnobj). Funkcije su Objekti
+
+U Scali, često pričamo o objektno-funkcionalnom programiranju. Što to znači? Što je zapravo Funkcija?
+
+Funkcija je set trait-ova. Točnije, funkcija koja uzima jedan argument je instanca Function1 trait-a. Ova jtrait definira <code>apply()</code> sintatik šugar koji smo spominjali ranije, dopuštajući vam da pozovete objekt kao što bi zvali funkciju.
+
+<pre>
+scala> object addOne extends Function1[Int, Int] {
+     |   def apply(m: Int): Int = m + 1
+     | }
+defined module addOne
+
+scala> addOne(1)
+res2: Int = 2
+</pre>
+
+Postoji Function0 - 22. Zašto 22? To je magični broj. Nikad nisam trebao funkciju sa više od 22 argumenta.
+
+Sintatički šugar apply-a pomaže ujediniti dualnost objektnog i funkcionalnog programiranja. Možete proslijeđivati klase i koristiti ih kao funkcije jer su funkcije samo instance klasa.
+
+Znači li to da svaki put kada definirate metodu u vašoj klasi, zapravo dobivate instancu Function*? Ne, metode u klasama su metode. Metode su definirane samostalno.
+
+Klase također mogu extend-ati Function i takve instance se mogu pozvati sa ().
+
+<pre>
+scala> class AddOne extends Function1[Int, Int] {
+     |   def apply(m: Int): Int = m + 1
+     | }
+defined class AddOne
+
+scala> val plusOne = new AddOne()
+plusOne: AddOne = <function1>
+
+scala> plusOne(1)
+res0: Int = 2
+</pre>
+
+Lijepi prečac za <code>extends Function1[Int, Int]</code> je <code>extends (Int => Int)</code>
+
+<pre>
+class AddOne extends (Int => Int) {
+  def apply(m: Int): Int = m + 1
+}
+</pre>
+
+h2(#package). Paketi
+
+Možete organizirati vaš kod unutar paketa
+
+<pre>
+package com.twitter.example
+</pre>
+
+na početku datoteke.
+
+Vrijednosti i funkcije ne mogu biti van klase ili objekta. Objekti su koristan alat za organizaciju statičkih funkcija.
+
+<pre>
+package com.twitter.example
+
+object colorHolder {
+  val BLUE = "Blue"
+  val RED = "Red"
+}
+</pre>
+
+Sada možete pristupiti članovima direktno
+
+<pre>
+println("the color is: " + com.twitter.example.colorHolder.BLUE)
+</pre>
+
+Primijetite što Scala repl kaže kada definirate objekt:
+
+<pre>
+scala> object colorHolder {
+     |   val Blue = "Blue"
+     |   val Red = "Red"
+     | }
+defined module colorHolder
+</pre>
+
+Ovo vam daje mali nagovještaj da su dizajneri Scale kreirali objekte kako bi bili dio Scala modul sustava.
+
+h2(#match). Pattern Matching
+
+Jedan od najkorisnijih dijelova Scale.
+
+Match-iranje na vrijednostima
+
+<pre>
+val times = 1
+
+times match {
+  case 1 => "one"
+  case 2 => "two"
+  case _ => "some other number"
+}
+</pre>
+
+Match-iranje sa guard-ovima
+
+<pre>
+times match {
+  case i if i == 1 => "one"
+  case i if i == 2 => "two"
+  case _ => "some other number"
+}
+</pre>
+
+Primijetite kako smo uhvatili vrijednost u varijabli 'i'.
+
+<code>_</code> u zadnjem case izrazu je wildcard; on osigurava da možemo obraditi svaki zahtjev. Inače ćete dobiti runtime error (a to ne želimo, no, no) ako proslijedite broj koji se ne match-ira. Više o tome kasnije.
+
+*Dobro je pogledati* Efektivna Scala ima mišljenje o <a href="http://twitter.github.com/effectivescala/#Functional programming-Pattern matching">when to use pattern matching</a> i <a href="http://twitter.github.com/effectivescala/#Formatting-Pattern matching">pattern matching formatting</a>. Tura kroz Scalu opisuje <a href="http://www.scala-lang.org/node/120">Pattern Matching</a>
+
+h3. Match-iranje na tipovima
+
+Možete koristiti <code>match</code> kako bi obradili vrijednosti različitih tipova na različit način.
+
+<pre>
+def bigger(o: Any): Any = {
+  o match {
+    case i: Int if i < 0 => i - 1
+    case i: Int => i + 1
+    case d: Double if d < 0.0 => d - 0.1
+    case d: Double => d + 0.1
+    case text: String => text + "s"
+  }
+}
+</pre>
+
+h3. Match-iranje na članovima klase
+
+Prisjetimo se našeg Calculator-a iz prijašnjih primjera.
+
+Idemo ga klasificirati prema tipu.
+
+Prvo teži način.
+
+<pre>
+def calcType(calc: Calculator) = calc match {
+  case _ if calc.brand == "HP" && calc.model == "20B" => "financial"
+  case _ if calc.brand == "HP" && calc.model == "48G" => "scientific"
+  case _ if calc.brand == "HP" && calc.model == "30B" => "business"
+  case _ => "unknown"
+}
+</pre>
+
+Idesh, ovo je boljelo. Dobro da Scala pruža lipe alate za ovakve stvari, juhuu.
+
+h2(#caseclass). Case Klase
+
+case klase se koriste kako bi prikladno pohranili i match-irali nad sadržajem klase. Možete ih kreirati bez korištenja new.
+
+<pre>
+scala> case class Calculator(brand: String, model: String)
+defined class Calculator
+
+scala> val hp20b = Calculator("HP", "20b")
+hp20b: Calculator = Calculator(hp,20b)
+
+</pre>
+
+case klase automatski imaju jednakost i lijepu ToString metodu baziranu na argumentima konstruktora.
+
+<pre>
+scala> val hp20b = Calculator("HP", "20b")
+hp20b: Calculator = Calculator(hp,20b)
+
+scala> val hp20B = Calculator("HP", "20b")
+hp20B: Calculator = Calculator(hp,20b)
+
+scala> hp20b == hp20B
+res6: Boolean = true
+</pre>
+
+case klase mogu imati metode baš kao normalne klase.
+
+h6. Case Klase sa pattern match-ingom
+
+case klase su dizajnirane kako bi se koristile sa pattern match-ingom. Pojednostavimo naš calculator klasifikator primjer.
+
+<pre>
+val hp20b = Calculator("HP", "20B")
+val hp30b = Calculator("HP", "30B")
+
+def calcType(calc: Calculator) = calc match {
+  case Calculator("HP", "20B") => "financial"
+  case Calculator("HP", "48G") => "scientific"
+  case Calculator("HP", "30B") => "business"
+  case Calculator(ourBrand, ourModel) => "Calculator: %s %s is of unknown type".format(ourBrand, ourModel)
+}
+</pre>
+
+Druge alternative za zadnji match
+
+<pre>
+  case Calculator(_, _) => "Calculator of unknown type"
+</pre>
+
+  ILI jednostavno možemo ne specificirati da je to Calculator.
+
+<pre>
+  case _ => "Calculator of unknown type"
+</pre>
+
+  ILI možemo napraviti re-bind match-irane vrijednosti sa drugim imenom
+
+<pre>
+  case c@Calculator(_, _) => "Calculator: %s of unknown type".format(c)
+</pre>
+
+h2(#exception). Iznimke
+
+Iznimke su dostupne u Scali kroz try-catch-finally sintaksu koja koristi pattern matching.
+
+<pre>
+try {
+  remoteCalculatorService.add(1, 2)
+} catch {
+  case e: ServerIsDownException => log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
+} finally {
+  remoteCalculatorService.close()
+}
+</pre>
+
+<code>try</code>s su također expression-orijentirane
+
+<pre>
+val result: Int = try {
+  remoteCalculatorService.add(1, 2)
+} catch {
+  case e: ServerIsDownException => {
+    log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
+    0
+  }
+} finally {
+  remoteCalculatorService.close()
+}
+</pre>
+
+Ovo nije primjer odličnog programerskog stila, samo primjer try-catch-finally koji rezultira u expressions-ima kao i većina stvari u Scali.
+
+Finally će se zvati nakon što je iznimka obrađena i nije dio expression-a.

From 331486c0fed03a6c12d1e3ccd951e3ad9c5ec9d4 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 27 Apr 2016 16:06:48 +0200
Subject: [PATCH 10/13] Corrected basic2.textile translation

---
 web/hr/basics2.textile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/web/hr/basics2.textile b/web/hr/basics2.textile
index 7f0895df..6661f693 100644
--- a/web/hr/basics2.textile
+++ b/web/hr/basics2.textile
@@ -72,7 +72,7 @@ res0: Long = 1
 
 Klase i Objekti mogu imati jednako ime. Objekt se zove 'Companion Object'.
 
-SLijedi jednostavan primjer kojemu je jedina svrha ukloniti potrebu korištenja 'new' kako bi kreirali instancu.
+Slijedi jednostavan primjer kojemu je jedina svrha ukloniti potrebu korištenja 'new' kako bi kreirali instancu.
 
 <pre>
 class Bar(foo: String)
@@ -87,7 +87,7 @@ h2(#fnobj). Funkcije su Objekti
 
 U Scali, često pričamo o objektno-funkcionalnom programiranju. Što to znači? Što je zapravo Funkcija?
 
-Funkcija je set trait-ova. Točnije, funkcija koja uzima jedan argument je instanca Function1 trait-a. Ova jtrait definira <code>apply()</code> sintatik šugar koji smo spominjali ranije, dopuštajući vam da pozovete objekt kao što bi zvali funkciju.
+Funkcija je set trait-ova. Točnije, funkcija koja uzima jedan argument je instanca Function1 trait-a. Ovaj trait definira <code>apply()</code> sintatik šugar koji smo spominjali ranije, dopuštajući vam da pozovete objekt kao što bi zvali funkciju.
 
 <pre>
 scala> object addOne extends Function1[Int, Int] {
@@ -247,7 +247,7 @@ hp20b: Calculator = Calculator(hp,20b)
 
 </pre>
 
-case klase automatski imaju jednakost i lijepu ToString metodu baziranu na argumentima konstruktora.
+case klase automatski imaju jednakost i lijepu toString metodu baziranu na argumentima konstruktora.
 
 <pre>
 scala> val hp20b = Calculator("HP", "20b")
@@ -310,7 +310,7 @@ try {
 }
 </pre>
 
-<code>try</code>s su također expression-orijentirane
+<code>try</code>-evi su također expression-orijentirani
 
 <pre>
 val result: Int = try {

From 6780316da097dbb74c11b156e5779f2b01dc884c Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Thu, 28 Apr 2016 16:14:24 +0200
Subject: [PATCH 11/13] Added coll2.textile Croatian translation; Corrected
 advanced-types.textile

---
 web/hr/advanced-types.textile |   4 +-
 web/hr/coll2.textile          | 395 ++++++++++++++++++++++++++++++++++
 2 files changed, 397 insertions(+), 2 deletions(-)
 create mode 100644 web/hr/coll2.textile

diff --git a/web/hr/advanced-types.textile b/web/hr/advanced-types.textile
index b07cebd3..f84a49d0 100644
--- a/web/hr/advanced-types.textile
+++ b/web/hr/advanced-types.textile
@@ -20,7 +20,7 @@ h2(#viewbounds). Pregled granica ("tipovi klasa")
 
 Ponekad ne morate definirati da je jedan tip jednak/inferioran/nadmoćan prema drugome, samo da bi ga mogli fake-ati sa konverzijama. Pregled granica specificira tip koji može biti "kao" neki drugi tip. Ovo ima smisla za operacije kod kojih je potrebno čitati objekte ali ne i mijenjati ih.
 
-*Implicitne* funkcije dopuštaju automatsku konverziju. Preciznije, one dopuštaju on-demand funkciju kada to može pomoći zadovoljiti type inference. e.g.:
+*Implicitne* funkcije dopuštaju automatsku konverziju. Preciznije, one dopuštaju on-demand funkciju kada to može pomoći zadovoljiti type inference. Npr.
 
 <pre>
 scala> implicit def strToInt(x: String) = x.toInt
@@ -60,7 +60,7 @@ scala> (new Container[Float]).addIt(123.2F)
 
 h2(#otherbounds). Ostali tipovi granica
 
-Metode mogu primijeniti još složenije tipove granica kroz implicitne parametre. Npr. <code>List</code> podržava <code>sum</code> na numeričkom sadržaju ali ne i na drugom tipu sadržaja. Svi Scala numerički tipovi ne dijele nadklase pa za to ne možemo samo reći <code>T <: Number</code>. Umjesto toga, Scala math biblioteka <a href="http://www.azavea.com/blogs/labs/2011/06/scalas-numeric-type-class-pt-1/"> definira implicitni tip <code>Numeric[T]</code> za prikladan T</a> tip. Zatim ga <code>List</code> definicija koristi:
+Metode mogu primijeniti još složenije tipove granica kroz implicitne parametre. Npr. <code>List</code> podržava <code>sum</code> na numeričkom sadržaju ali ne i na drugom tipu sadržaja. Svi Scala numerički tipovi ne dijele nadklase pa zato ne možemo samo reći <code>T <: Number</code>. Umjesto toga, Scala math biblioteka <a href="http://www.azavea.com/blogs/labs/2011/06/scalas-numeric-type-class-pt-1/"> definira implicitni tip <code>Numeric[T]</code> za prikladan T</a> tip. Zatim ga <code>List</code> definicija koristi:
 
 <pre>
 sum[B >: A](implicit num: Numeric[B]): B
diff --git a/web/hr/coll2.textile b/web/hr/coll2.textile
new file mode 100644
index 00000000..a6b69bd0
--- /dev/null
+++ b/web/hr/coll2.textile
@@ -0,0 +1,395 @@
+---
+prev: sbt.textile
+next: specs.textile
+title: Još kolekcija
+layout: post
+---
+
+Scala pruža lijep set implementacija kolekcija. Također pruža neke apstrakcije nad tipovima kolekcija. To vam dopušta pisanje koda koji može raditi sa kolekcijama tipa <code>Foo</code> bez brige je li kolekcija <code>List</code>, <code>Set</code>, ili što već...
+
+"Ova stranica":http://www.decodified.com/scala/collections-api.xml pruža dobar način kako implementirati na standardan način i sve povezati sa scaladoc-om.
+
+* "Osnove":#basics Tipovi kolekcija koje ćete stalno koristiti
+* "Hijerahija":#hierarchy Apstrakcije kolekcija
+* "Metode":#methods
+* "Mutable":#mutable
+* "Java kolekcije":#java jednostavno funkcioniraju
+
+h2(#basics). Osnove
+
+h3. List
+
+Standardna link-ana lista.
+
+<pre>
+scala> List(1, 2, 3)
+res0: List[Int] = List(1, 2, 3)
+</pre>
+
+Možete s njom sve što bi i očekivali u funkcijskom jeziku.
+
+<pre>
+scala> 1 :: 2 :: 3 :: Nil
+res1: List[Int] = List(1, 2, 3)
+</pre>
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/immutable/List.html
+
+h3. Set
+
+Set-ovi nemaju duplikate
+
+<pre>
+scala> Set(1, 1, 2)
+res2: scala.collection.immutable.Set[Int] = Set(1, 2)
+</pre>
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/immutable/Set.html
+
+h3. Seq
+
+Sekvence imaju definiran redoslijed.
+
+<pre>
+scala> Seq(1, 1, 2)
+res3: Seq[Int] = List(1, 1, 2)
+</pre>
+
+(Primijetite da je to vratilo listu. Seq je trait; List je implementacija Seq-a. Postoji standardni objekt <code>Seq</code> koji, kao što ovdje vidite, kreira Lists.)
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/Seq.html
+
+h3. Map
+
+Mape su key value kontenjeri.
+
+<pre>
+scala> Map('a' -> 1, 'b' -> 2)
+res4: scala.collection.immutable.Map[Char,Int] = Map((a,1), (b,2))
+</pre>
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/immutable/Map.html
+
+h2(#hierarchy). Hijerarhija
+
+To su sve trait-ovi, mutable i immutable paketi imaju standardne i posebne implementacije.
+
+h3. Traversable
+
+Sve kolekcije mogu biti međusobno miješane. Ovaj trait definira standardne funkcijske kombinatore. Ovi kombinatori su pisani u stilu @foreach@, koje kolekcije moraju implementirati.
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/Traversable.html
+
+h3. Iterable
+
+@iterator()@ metoda nam pruža Iterator kroz elemente.
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/Iterable.html
+
+h3. Seq
+
+Sekvenca item-a sa redoslijedom (ordering).
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/Seq.html
+
+h3. Set
+
+Kolekcija item-a bez duplikata.
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/immutable/Set.html
+
+h3. Map
+
+Key Value Pairs.
+
+*Dobro je pogledati* "API doc":http://www.scala-lang.org/api/current/scala/collection/immutable/Map.html
+
+h2(#methods). Metode
+
+h3. Traversable
+
+Sve ove metode su odmah dostupne. Argumenti i povratni tipovi neće uvijek izgledati isto budući da ih podklase mogu pregaziti (override).
+
+<pre>
+def head : A
+def tail : Traversable[A]
+</pre>
+
+Ovdje su Funkcionalni Kombinatori definirani.
+
+<code>
+def map [B] (f: (A) => B) : CC[B]
+</code>
+
+vraća kolekciju sa svakim elementom transformiranim sa @f@
+
+<code>
+def foreach[U](f: Elem => U): Unit
+</code>
+
+izvršava @f@ kroz svaki element u kolekciji.
+
+<code>
+def find (p: (A) => Boolean) : Option[A]
+</code>
+
+vraća prvi element koji zadovoljava funkciju
+
+<code>
+def filter (p: (A) => Boolean) : Traversable[A]
+</code>
+
+vraća kolekciju sa svim elementima koji zadovoljavaju funkciju
+
+Particioniranje:
+
+<code>
+def partition (p: (A) ⇒ Boolean) : (Traversable[A], Traversable[A])
+</code>
+
+Dijeli kolekciju u dva dijela prema funkciji
+
+<code>
+def groupBy [K] (f: (A) => K) : Map[K, Traversable[A]]
+</code>
+
+Konverzija:
+
+Zanimljivo, možete konvertirati jednu kolekciju u drugu.
+
+<pre>
+def toArray : Array[A]
+def toArray [B >: A] (implicit arg0: ClassManifest[B]) : Array[B]
+def toBuffer [B >: A] : Buffer[B]
+def toIndexedSeq [B >: A] : IndexedSeq[B]
+def toIterable : Iterable[A]
+def toIterator : Iterator[A]
+def toList : List[A]
+def toMap [T, U] (implicit ev: <:<[A, (T, U)]) : Map[T, U]
+def toSeq : Seq[A]
+def toSet [B >: A] : Set[B]
+def toStream : Stream[A]
+def toString () : String
+def toTraversable : Traversable[A]
+</pre>
+
+HaJdm0 konvertirati Map u Array. Možete dobiti Array Key Value pairs.
+
+<pre>
+scala> Map(1 -> 2).toArray
+res41: Array[(Int, Int)] = Array((1,2))
+</pre>
+
+h3. Iterable
+
+Dodaje pristup iterator-u.
+
+<pre>
+  def iterator: Iterator[A]
+</pre>
+
+Što vam Iterator pruža?
+
+<pre>
+def hasNext(): Boolean
+def next(): A
+</pre>
+
+Ovo je vrlo Java like. Nećete vidjeti da se iteratori često koriste u Scali, prije ćete vidjeti funkcionalne kombinatore.
+
+h3. Set
+
+<pre>
+  def contains(key: A): Boolean
+  def +(elem: A): Set[A]
+  def -(elem: A): Set[A]
+</pre>
+
+h3. Map
+
+Sekvenca ključeva i vrijednosti sa pretraživanjem po ključu.
+
+Proslijedite List of Pairs u apply() na način:
+
+<pre>
+scala> Map("a" -> 1, "b" -> 2)
+res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,1), (b,2))
+</pre>
+
+Ili nešto kao:
+
+<pre>
+scala> Map(("a", 2), ("b", 2))
+res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,2), (b,2))
+</pre>
+
+h6. Digresija
+
+Što je <code>-></code>? To nije specijalna sintaksa, to je metoda koja vraća Tuple.
+
+<pre>
+scala> "a" -> 2
+
+res0: (java.lang.String, Int) = (a,2)
+</pre>
+
+Zapamtite, to je samo šugar za
+
+<pre>
+scala> "a".->(2)
+
+res1: (java.lang.String, Int) = (a,2)
+</pre>
+
+Također možete kreirati jedan sa <code>++</code>
+
+<pre>
+scala> Map.empty ++ List(("a", 1), ("b", 2), ("c", 3))
+res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,1), (b,2), (c,3))
+</pre>
+
+h3. Često korištene podklase
+
+*HashSet i HashMap* Brzi pregled, najkorištenije forme tih kolekcija. "HashSet API":http://www.scala-lang.org/api/current/scala/collection/immutable/HashSet.html, "HashMap API":http://www.scala-lang.org/api/current/scala/collection/immutable/HashMap.html
+
+*TreeMap* Podklasa SortedMap, pruža nam posložen pristup (ordered access). "TreeMap API":http://www.scala-lang.org/api/current/scala/collection/immutable/TreeMap.html
+
+*Vector* Brza nasumična selekcija i brze nadogradnje. "Vector API":http://www.scala-lang.org/api/current/scala/collection/immutable/Vector.html
+
+<pre>
+scala> IndexedSeq(1, 2, 3)
+res0: IndexedSeq[Int] = Vector(1, 2, 3)
+</pre>
+
+*Range* Orderirana sekvenca Int-ova koja je razlomljena. Često ćete ovo vidjeti tamo gdje je for-loop prije korišten. "Range API":http://www.scala-lang.org/api/current/scala/collection/immutable/Range.html
+
+<pre>
+scala> for (i <- 1 to 3) { println(i) }
+1
+2
+3
+</pre>
+
+Range-vi imaju dostupne standardne funkcionalne kombinatore.
+
+<pre>
+scala> (1 to 3).map { i => i }
+res0: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3)
+</pre>
+
+h3. Default
+
+Korištenje apply metode na trait-ovima će vam dati instancu standardne implementacije, Npr. Iterable(1, 2) vraća List kao standardnu implementaciju.
+
+<pre>
+scala> Iterable(1, 2)
+
+res0: Iterable[Int] = List(1, 2)
+</pre>
+
+Isto kao sa Seq, kao što smo vidjeli ranije
+
+<pre>
+scala> Seq(1, 2)
+res3: Seq[Int] = List(1, 2)
+
+scala> Iterable(1, 2)
+res1: Iterable[Int] = List(1, 2)
+
+scala> Sequence(1, 2)
+warning: there were deprecation warnings; re-run with -deprecation for details
+res2: Seq[Int] = List(1, 2)
+</pre>
+
+Set
+
+<pre>
+scala> Set(1, 2)
+res31: scala.collection.immutable.Set[Int] = Set(1, 2)
+</pre>
+
+h3. Neki opisni trait-ovi
+
+*IndexedSeq* brzi nasumični-pristup (random-access) elementima i brze length operacije. "API doc":http://www.scala-lang.org/api/current/scala/collection/IndexedSeq.html
+
+*LinearSeq* brzi pristup samo prvim elementima putem head-a, ali također posjeduje brzu tail operaciju. "API doc":http://www.scala-lang.org/api/current/scala/collection/LinearSeq.html
+
+h4. Mutable vs. Immutable
+
+immutable
+
+Prednosti
+* Ne može se mijenjati u višestrukim dretvama
+
+Mane
+* Ne može se uopće mijenjati
+
+Scala nam dopušta da budemo pragmatični, pruža nam immutability ali nas ne kažnjava zato što trebamo mutability. Ovo je vrlo slično var vs. val. Uvijek započinjemo sa val i pomičemo se prema var kada je to potrebno.
+
+Više volimo započeti sa immutable verzijama kolekcija ali se također volimo prebaciti na mutable ako performanse tako diktiraju, yeah. Korištenje immutable kolekcija znači da nećete slučajno promijeniti stvari u više dretvi.
+
+h2(#mutable). Mutable
+
+Sve dosad spomenute klase su immutable. Sad pogledajmo mutable kolekcije.
+
+*HashMap* definira @getOrElseUpdate@, @+=@ "HashMap API":http://www.scala-lang.org/api/current/scala/collection/mutable/HashMap.html
+
+<pre>
+scala> val numbers = collection.mutable.Map(1 -> 2)
+numbers: scala.collection.mutable.Map[Int,Int] = Map((1,2))
+
+scala> numbers.get(1)
+res0: Option[Int] = Some(2)
+
+scala> numbers.getOrElseUpdate(2, 3)
+res54: Int = 3
+
+scala> numbers
+res55: scala.collection.mutable.Map[Int,Int] = Map((2,3), (1,2))
+
+scala> numbers += (4 -> 1)
+res56: numbers.type = Map((2,3), (4,1), (1,2))
+</pre>
+
+*ListBuffer i ArrayBuffer* Definira @+=@ "ListBuffer API":http://www.scala-lang.org/api/current/scala/collection/mutable/ListBuffer.html, "ArrayBuffer API":http://www.scala-lang.org/api/current/scala/collection/mutable/ArrayBuffer.html
+
+*LinkedList i DoubleLinkedList* "LinkedList API":http://www.scala-lang.org/api/current/scala/collection/mutable/LinkedList.html, "DoubleLinkedList API":http://www.scala-lang.org/api/current/scala/collection/mutable/DoubleLinkedList.html
+
+*PriorityQueue* "API doc":http://www.scala-lang.org/api/current/scala/collection/mutable/PriorityQueue.html
+
+*Stack and ArrayStack* "Stack API":http://www.scala-lang.org/api/current/scala/collection/mutable/Stack.html, "ArrayStack API":http://www.scala-lang.org/api/current/scala/collection/mutable/ArrayStack.html
+
+*StringBuilder* Zanimljivo, StringBuilder je kolekcija. "API doc":http://www.scala-lang.org/api/current/scala/collection/mutable/StringBuilder.html
+
+h2(#java). Život sa Java-om
+
+Lako se možete pomicati između Java i Scala tipova kolekcija koristeći konverzije koje su dostupne na <a href="http://www.scala-lang.org/api/current/index.html#scala.collection.JavaConverters$">JavaConverters package</a>. To povezuje uobičajeno korištene Java kolekcije sa <code>asScala</code> metodama i Scala kolekcije sa <code>asJava</code> metodama.
+
+<pre>
+   import scala.collection.JavaConverters._
+   val sl = new scala.collection.mutable.ListBuffer[Int]
+   val jl : java.util.List[Int] = sl.asJava
+   val sl2 : scala.collection.mutable.Buffer[Int] = jl.asScala
+   assert(sl eq sl2)
+</pre>
+
+Dvosmjerne konverzije:
+
+<pre>
+scala.collection.Iterable <=> java.lang.Iterable
+scala.collection.Iterable <=> java.util.Collection
+scala.collection.Iterator <=> java.util.{ Iterator, Enumeration }
+scala.collection.mutable.Buffer <=> java.util.List
+scala.collection.mutable.Set <=> java.util.Set
+scala.collection.mutable.Map <=> java.util.{ Map, Dictionary }
+scala.collection.mutable.ConcurrentMap <=> java.util.concurrent.ConcurrentMap
+</pre>
+
+Dodatno, pružene su i sljedeće jednosmjerne konverzije:
+
+<pre>
+scala.collection.Seq => java.util.List
+scala.collection.mutable.Seq => java.util.List
+scala.collection.Set => java.util.Set
+scala.collection.Map => java.util.Map
+</pre>

From d9e42098d288cc3247a2472d02a466022a66b466 Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Tue, 3 May 2016 12:12:47 +0200
Subject: [PATCH 12/13] Added Croatian translation of collections.textile

---
 web/hr/collections.textile | 424 +++++++++++++++++++++++++++++++++++++
 1 file changed, 424 insertions(+)
 create mode 100644 web/hr/collections.textile

diff --git a/web/hr/collections.textile b/web/hr/collections.textile
new file mode 100644
index 00000000..1163fb02
--- /dev/null
+++ b/web/hr/collections.textile
@@ -0,0 +1,424 @@
+---
+prev: basics2.textile
+next: pattern-matching-and-functional-composition.textile
+title: Kolekcije
+layout: post
+---
+
+Ova lekcija sadržava:
+
+* Osnovne strukture podataka
+** "Arrays":#Arrays
+** "Liste":#Lists
+** "Sets":#Sets
+** "Tuple":#Tuple
+** "Mape":#Maps
+** "Option":#Option
+* Funkcionalni Kombinatori
+** "map":#map
+** "foreach":#foreach
+** "filter":#filter
+** "zip":#zip
+** "partition":#partition
+** "find":#find
+** "drop and dropWhile":#drop
+** "foldRight and foldLeft":#fold
+** "flatten":#flatten
+** "flatMap":#flatMap
+** "Generalizirani funkcionalni kombinatori":#generalized
+** "Map?":#vsMap
+
+h1. Osnovne strukture podataka
+
+Scala pruža neke lijepe kolekcije.
+
+*Dobro je pogledati* Efektivna Scala ima mišljenje kako koristiti <a href="http://twitter.github.com/effectivescala/#Collections">collections</a>.
+
+h2(#Arrays). Arrays
+
+Array-evi održavaju order, mogu sadržavati duplikate, i mutable su.
+
+<pre>
+scala> val numbers = Array(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+numbers: Array[Int] = Array(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+
+scala> numbers(3) = 10
+</pre>
+
+h2(#Lists). Liste
+
+Liste sadržavaju order, mogu sadržavati duplikate, i immutable su.
+
+<pre>
+scala> val numbers = List(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+numbers: List[Int] = List(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+
+scala> numbers(3) = 10
+<console>:9: error: value update is not a member of List[Int]
+              numbers(3) = 10
+</pre>
+
+h2(#Sets). Sets
+
+Set-ovi ne održavaju order i nemaju duplikata
+
+<pre>
+scala> val numbers = Set(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+numbers: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)
+</pre>
+
+h2(#Tuple). Tuple
+
+Tuple grupira jednostavne logičke kolekcije item-a bez korištenja klase.
+
+<pre>
+scala> val hostPort = ("localhost", 80)
+hostPort: (String, Int) = (localhost, 80)
+</pre>
+
+Naspram case klasa, nemaju imenovane akcesore (accessors), umjesto toga imaju akcesore imenovane prema njihovoj poziciji i 1-based su, a ne 0-based.
+
+<pre>
+scala> hostPort._1
+res0: String = localhost
+
+scala> hostPort._2
+res1: Int = 80
+</pre>
+
+Tuple-ovi fitaju sa pattern matching vrlo lipo.
+
+<pre>
+hostPort match {
+  case ("localhost", port) => ...
+  case (host, port) => ...
+}
+</pre>
+
+Tuple ima specijalni umak za kreiranje Tuple-ova od 2 vrijednosti: <code>-></code>
+
+<pre>
+scala> 1 -> 2
+res0: (Int, Int) = (1,2)
+</pre>
+
+*Dobro je pogledati* Efektivna Scala ima mišljenje <a href="http://twitter.github.com/effectivescala/#Functional programming-Destructuring bindings">destructuring bindings</a> ("odpakiranje" tuple-a).
+
+h2(#Maps). Mape
+
+Mogu sadržavati osnovne tipove podataka.
+
+<pre>
+Map(1 -> 2)
+Map("foo" -> "bar")
+</pre>
+
+Ovo izgleda kao specijalna sintaksa ali sjetite se naše diskusije gdje se Tuple <code>-></code> može koristiti za kreiranje Tuple-ova.
+Map() također koristi taj varijabilni argument koji smo naučili u lekciji #1: <code>Map(1 -> "one", 2 -> "two")</code> koji se proširuje u <code>Map((1, "one"), (2, "two"))</code> sa prvim elementom koji je ključ i drugim elementom koji je vrijednost Map-e.
+
+Mape same mogu sadržavati Mape ili čak i funkcije kao vrijednosti.
+
+<pre>
+Map(1 -> Map("foo" -> "bar"))
+</pre>
+
+<pre>
+Map("timesTwo" -> { timesTwo(_) })
+</pre>
+
+h2(#Option). Option
+
+<code>Option</code> je kontenjer koji može ali ne mora sadržavati nešto.
+
+Klasičan interface za Option izgleda:
+
+<pre>
+trait Option[T] {
+  def isDefined: Boolean
+  def get: T
+  def getOrElse(t: T): T
+}
+</pre>
+
+Option je sam po sebi generičan i ima dvije podklase: <code>Some[T]</code> ili <code>None</code>
+
+Pogledajmo primjer kako se Option koristi:
+
+<code>Map.get</code> koristi <code>Option</code> za njegov povratni tip.
+Option nam govori da metoda možda neće vratiti ono što ste tražili.
+
+<pre>
+scala> val numbers = Map("one" -> 1, "two" -> 2)
+numbers: scala.collection.immutable.Map[java.lang.String,Int] = Map(one -> 1, two -> 2)
+
+scala> numbers.get("two")
+res0: Option[Int] = Some(2)
+
+scala> numbers.get("three")
+res1: Option[Int] = None
+</pre>
+
+Sada se čini da su naši podaci zapeli u <code>Option</code>. Kako se nosimo s tim?
+
+Na prvu, pomislili bi da trebate napraviti nešto kondicionalno bazirano na <code>isDefined</code> metodi.
+
+<pre>
+// We want to multiply the number by two, otherwise return 0.
+val result = if (res1.isDefined) {
+  res1.get * 2
+} else {
+  0
+}
+</pre>
+
+Mi bi vam preporučili da koristite ili <code>getOrElse</code> ili pattern matching kako bi uspješno baratali rezultatom.
+
+<code>getOrElse</code> vam dopušta da jednostavno definirate standardnu vrijednost.
+
+<pre>
+val result = res1.getOrElse(0) * 2
+</pre>
+
+Pattern matching fita prirodno sa <code>Option</code>.
+
+<pre>
+val result = res1 match {
+  case Some(n) => n * 2
+  case None => 0
+}
+</pre>
+
+*Dobro je pogledati* Effective Scala ima mišljenje o <a href="http://twitter.github.com/effectivescala/#Functional programming-Options">Options</a>.
+
+h1(#combinators). Funkcionalni Kombinatori
+
+<code>List(1, 2, 3) map squared</code> pridružuje funkciju <code>squared</code> elementima liste, vraćajući novu listu, vjerojatno <code>List(1, 4, 9)</code>. Operacije kao <code>map</code> zovemo <em>kombinatori</em>. (Ako želite bolju definiciju vjerojatno će vas zanimati <a href="http://stackoverflow.com/questions/7533837/explanation-of-combinators-for-the-working-man">Explanation of combinators</a> na Stackoverflow-u.) Njihova najčešća primjena je na standardnim strukturama podataka.
+
+h2(#map). map
+
+Evaulira funkciju kroz svaki element liste, vraćajući listu sa istim brojem elemenata.
+
+<pre>
+scala> val numbers = List(1, 2, 3, 4)
+numbers: List[Int] = List(1, 2, 3, 4)
+
+scala> numbers.map((i: Int) => i * 2)
+res0: List[Int] = List(2, 4, 6, 8)
+</pre>
+
+ili proslijedite u funkciju (Scala kompajler automatski konvertira našu metodu u funkciju)
+
+<pre>
+
+scala> def timesTwo(i: Int): Int = i * 2
+timesTwo: (i: Int)Int
+
+scala> numbers.map(timesTwo)
+res0: List[Int] = List(2, 4, 6, 8)
+</pre>
+
+h2(#foreach). foreach
+
+foreach je kao mapa ali ne vraća ništa, nada. foreach je namijenjen samo za side-effects.
+
+<pre>
+scala> numbers.foreach((i: Int) => i * 2)
+</pre>
+
+vraća ništa.
+
+Možete pokušati pohraniti return u vrijednost ali to će biti tipa Unit (tj. void)
+
+<pre>
+scala> val doubled = numbers.foreach((i: Int) => i * 2)
+doubled: Unit = ()
+</pre>
+
+h2(#filter). filter
+
+uklanja sve elemente gdje funkcija koju proslijeđujete očekuje false.  Funkcije koje pozivaju Boolean se obično zovu predikatne funkcije.
+
+<pre>
+scala> numbers.filter((i: Int) => i % 2 == 0)
+res0: List[Int] = List(2, 4)
+</pre>
+
+<pre>
+scala> def isEven(i: Int): Boolean = i % 2 == 0
+isEven: (i: Int)Boolean
+
+scala> numbers.filter(isEven)
+res2: List[Int] = List(2, 4)
+</pre>
+
+h2(#zip). zip
+
+zip agregira sadržaj dvije liste u jednu listu parova.
+
+<pre>
+scala> List(1, 2, 3).zip(List("a", "b", "c"))
+res0: List[(Int, String)] = List((1,a), (2,b), (3,c))
+</pre>
+
+h2(#partition). partition
+
+<code>partition</code> dijeli listu ovisno o tome gdje dolazi do pucanja s respektom prema predikatnoj funkciji.
+
+<pre>
+scala> val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+scala> numbers.partition(_ % 2 == 0)
+res0: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
+</pre>
+
+h2(#find). find
+
+find vraća prvi element kolekcije koja match-a predikatnu funkciju.
+
+<pre>
+scala> numbers.find((i: Int) => i > 5)
+res0: Option[Int] = Some(6)
+</pre>
+
+h2(#drop). drop & dropWhile
+
+<code>drop</code> dropa prvih i elemenata
+
+<pre>
+scala> numbers.drop(5)
+res0: List[Int] = List(6, 7, 8, 9, 10)
+</pre>
+
+<code>dropWhile</code> uklanja prve elemente koji match-iraju predikatnu funkciju. Npr. ako koristimo <code>dropWhile</code> kako bi uklonili neobične brojeve iz naše liste brojeva, <code>1</code> je drop-an (ali ne i <code>3</code> koji je "zaštićen" sa <code>2</code>).
+
+<pre>
+scala> numbers.dropWhile(_ % 2 != 0)
+res0: List[Int] = List(2, 3, 4, 5, 6, 7, 8, 9, 10)
+</pre>
+
+h2(#fold). foldLeft
+
+<pre>
+scala> numbers.foldLeft(0)((m: Int, n: Int) => m + n)
+res0: Int = 55
+</pre>
+
+0 je početna vrijednost (zapamtite da su brojevi List[Int]), i m
+se ponaša kao akumulator.
+
+Vizualno:
+
+<pre>
+scala> numbers.foldLeft(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
+m: 0 n: 1
+m: 1 n: 2
+m: 3 n: 3
+m: 6 n: 4
+m: 10 n: 5
+m: 15 n: 6
+m: 21 n: 7
+m: 28 n: 8
+m: 36 n: 9
+m: 45 n: 10
+res0: Int = 55
+</pre>
+
+h3. foldRight
+
+Je isto kao i foldLeft osim što se pokreće u suprotnom smjeru.
+
+<pre>
+scala> numbers.foldRight(0) { (m: Int, n: Int) => println("m: " + m + " n: " + n); m + n }
+m: 10 n: 0
+m: 9 n: 10
+m: 8 n: 19
+m: 7 n: 27
+m: 6 n: 34
+m: 5 n: 40
+m: 4 n: 45
+m: 3 n: 49
+m: 2 n: 52
+m: 1 n: 54
+res0: Int = 55
+</pre>
+
+h2(#flatten). flatten
+
+flatten lomi jednu razinu nested strukture.
+
+<pre>
+scala> List(List(1, 2), List(3, 4)).flatten
+res0: List[Int] = List(1, 2, 3, 4)
+</pre>
+
+h2(#flatMap). flatMap
+
+flatMap je često korišten kombinator koji kombinira mapping i flattening. flatMap uzima funkciju koja radi sa nested listama i zatim ponovno spaja rezultat.
+
+<pre>
+scala> val nestedNumbers = List(List(1, 2), List(3, 4))
+nestedNumbers: List[List[Int]] = List(List(1, 2), List(3, 4))
+
+scala> nestedNumbers.flatMap(x => x.map(_ * 2))
+res0: List[Int] = List(2, 4, 6, 8)
+</pre>
+
+Mislite na to kao na kraticu za mapping i zatim flattening:
+
+<pre>
+scala> nestedNumbers.map((x: List[Int]) => x.map(_ * 2)).flatten
+res1: List[Int] = List(2, 4, 6, 8)
+</pre>
+
+taj primjer koji poziva map i zatim flatten je primjer "kombinator"-like prirode tih funkcija.
+
+*Dobro je pogledati* Efektivna Scala ima mišljenje o tome <a href="http://twitter.github.com/effectivescala/#Functional programming-`flatMap`">flatMap</a>.
+
+h2(#generalized). Generalizirani funkcijski kombinatori
+
+Sada smo naučili osnovne funkcije za rad sa kombinatorima.
+
+Sada želimo sami napisati naše funkcijske kombinatore.
+
+Zanimljivo, svaki funkcijski kombinator prikazan ranije može biti napisan na vrhu fold-a. Pogledajmo neke primjere.
+
+<pre>
+def ourMap(numbers: List[Int], fn: Int => Int): List[Int] = {
+  numbers.foldRight(List[Int]()) { (x: Int, xs: List[Int]) =>
+    fn(x) :: xs
+  }
+}
+
+scala> ourMap(numbers, timesTwo(_))
+res0: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
+</pre>
+
+Zašto <tt>List[Int]()</tt>? Scala nije bila dovoljno pametna i nije shvatila da želite praznu listu Int-ova u koju bi to akumulirali.
+
+h2(#vsMap). Map?
+
+Svi prikazani funkcijski kombinatori također rade na Maps. Maps se može promatrati kao lista parova kako bi funkcije koje ste pisali radile na paru ključeva i vrijednosti u Map.
+
+<pre>
+scala> val extensions = Map("steve" -> 100, "bob" -> 101, "joe" -> 201)
+extensions: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101), (joe,201))
+</pre>
+
+Sada filter-irajte svaki zapis čija je ekstenzija broja manja od 200.
+
+<pre>
+scala> extensions.filter((namePhone: (String, Int)) => namePhone._2 < 200)
+res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
+</pre>
+
+Zato što vam daje tuple, morate povući ključeve i vrijednosti sa njihovim pozicijskim akcesorima. Sretno!
+
+Srećom za nas, zapravo možemo koristiti pattern match za lipo izvlačenje ključeva i vrijednosti.
+
+<pre>
+scala> extensions.filter({case (name, extension) => extension < 200})
+res0: scala.collection.immutable.Map[String,Int] = Map((steve,100), (bob,101))
+</pre>
+
+Zašto ovo radi? Zašto možete proslijediti parcijalni pattern match?
+
+Vidimo se sljedeći tjedan!

From c8eee27847a7a17a9d9c3936c292c9a97f8037ef Mon Sep 17 00:00:00 2001
From: Franjo Boljkovac <franjo.boljkovac@instantor.com>
Date: Wed, 4 May 2016 14:25:04 +0200
Subject: [PATCH 13/13] Added Croatian translation of concurrency.textile

---
 web/hr/concurrency.textile | 474 +++++++++++++++++++++++++++++++++++++
 1 file changed, 474 insertions(+)
 create mode 100644 web/hr/concurrency.textile

diff --git a/web/hr/concurrency.textile b/web/hr/concurrency.textile
new file mode 100644
index 00000000..549333f7
--- /dev/null
+++ b/web/hr/concurrency.textile
@@ -0,0 +1,474 @@
+---
+prev: specs.textile
+next: java.textile
+title: Konkurentnost u Scali
+layout: post
+---
+
+* "Runnable/Callable":#runnable
+* "Dretve":#Thread
+* "Executors/ExecutorService":#executor
+* "Futures":#Future
+* "Sigurnosni problem dretvi":#danger
+* "Npr. - Search Engine":#example
+* "Solutions":#solutions
+
+h2(#runnable). Runnable/Callable
+
+Runnable ima single metodu koja ne vraća vrijednost.
+
+<pre>
+trait Runnable {
+  def run(): Unit
+}
+</pre>
+
+Callable je sličan, ali vraća vrijednost
+
+<pre>
+trait Callable[V] {
+  def call(): V
+}
+</pre>
+
+
+h2(#Thread). Dretve
+
+Scala konkurentnost je izgrađena na temelju Java concurrency modela.
+
+Na Oracle(Sun) JVM-ovima, sa velikim IO opterećenjem, možemo pokretati tisuće dretvi na jednoj mašini.
+
+Thread uzima Runnable.  Morate pozvati @start@ na Thread kako bi mogao pokrenuti Runnable.
+
+<pre>
+scala> val hello = new Thread(new Runnable {
+  def run() {
+    println("hello world")
+  }
+})
+hello: java.lang.Thread = Thread[Thread-3,5,main]
+
+scala> hello.start
+hello world
+
+</pre>
+
+Kada vidite klasu koja implementira Runnable, znate da je namijenjena pokretanju u dretvi.
+
+h3. Nešto single-dretvovano
+
+Slijedi dio koda koji radi ali ima problema, hm, tko zna što mu je...
+
+<pre>
+import java.net.{Socket, ServerSocket}
+import java.util.concurrent.{Executors, ExecutorService}
+import java.util.Date
+
+class NetworkService(port: Int, poolSize: Int) extends Runnable {
+  val serverSocket = new ServerSocket(port)
+
+  def run() {
+    while (true) {
+      // This will block until a connection comes in.
+      val socket = serverSocket.accept()
+      (new Handler(socket)).run()
+    }
+  }
+}
+
+class Handler(socket: Socket) extends Runnable {
+  def message = (Thread.currentThread.getName() + "\n").getBytes
+
+  def run() {
+    socket.getOutputStream.write(message)
+    socket.getOutputStream.close()
+  }
+}
+
+(new NetworkService(2020, 2)).run
+</pre>
+
+Svaki zahtjev će se odazivati na trenutnu dretvu, koja je uvijek @main@.
+
+Glavna mana ovog koda je da samo jedan zahtjev može dobiti odgovor!
+
+Možete svaki zahtjev staviti u dretvu. Jednostavno zamijenite
+
+<pre>
+(new Handler(socket)).run()
+</pre>
+
+sa
+
+<pre>
+(new Thread(new Handler(socket))).start()
+</pre>
+
+Ali što ako želite ponovno iskoristiti dretve ili želite nešto drugo s njima?
+
+
+h2(#executor). Executori
+
+Sa izlaskom Jave 5 odlučeno je da je potrebno više abstraktnih interface-a prema dretvama.
+
+Možete dobiti @ExecutorService@ koristeći statičke metode na @Executors@ objektima.  Te metode vam pružaju mogućnost konfiguracije na  @ExecutorService@ sa raznim stvarima kao što je thread pooling.
+
+Slijedi reorganizirani old blocking network server primjer napisan sa mogućnošću konkuretnih zahtjeva.
+
+<pre>
+import java.net.{Socket, ServerSocket}
+import java.util.concurrent.{Executors, ExecutorService}
+import java.util.Date
+
+class NetworkService(port: Int, poolSize: Int) extends Runnable {
+  val serverSocket = new ServerSocket(port)
+  val pool: ExecutorService = Executors.newFixedThreadPool(poolSize)
+
+  def run() {
+    try {
+      while (true) {
+        // This will block until a connection comes in.
+        val socket = serverSocket.accept()
+        pool.execute(new Handler(socket))
+      }
+    } finally {
+      pool.shutdown()
+    }
+  }
+}
+
+class Handler(socket: Socket) extends Runnable {
+  def message = (Thread.currentThread.getName() + "\n").getBytes
+
+  def run() {
+    socket.getOutputStream.write(message)
+    socket.getOutputStream.close()
+  }
+}
+
+(new NetworkService(2020, 2)).run
+</pre>
+
+U primjeru koji slijedi nalazi se zapis povezivanja na prethodni primjer i vidimo kako se interne dretve ponovno iskorištavaju.
+
+<pre>
+$ nc localhost 2020
+pool-1-thread-1
+
+$ nc localhost 2020
+pool-1-thread-2
+
+$ nc localhost 2020
+pool-1-thread-1
+
+$ nc localhost 2020
+pool-1-thread-2
+</pre>
+
+
+h2(#Future). Futures
+
+@Future@ predstavlja asinkronu komputaciju.  Možete wrap-ati vašu komputaciju u Future i kada trebate rezultat, jednostavno možete pozvati blocking @get()@ metodu na njoj. @Executor@ vraća @Future@. Ako koristite Finagle RPC sustav, možete koristiti @Future@ instance kako bi pohranili rezultate koji još možda nisu stigli.
+
+@FutureTask@ je Runnable i dizajniran je kako bi se pokretao sa @Executor@
+
+<pre>
+val future = new FutureTask[String](new Callable[String]() {
+  def call(): String = {
+    searcher.search(target);
+}})
+executor.execute(future)
+</pre>
+
+Sadas trebamo rezultate pa krenimo.
+
+<pre>
+val blockingResult = future.get()
+</pre>
+
+*Dobro je pogledati* <a href="finagle.html">Scala School's Finagle stranica</a> ima pregršt primjera korištenja <code>Future</code>, uključujući neke lijepe načine za njihovu kombinaciju. Efektivna Scala ima mišljenje o tome <a href="http://twitter.github.com/effectivescala/#Twitter's standard libraries-Futures">Futures</a> .
+
+h2(#danger). Sigurnosni problem dretvi
+
+<pre>
+class Person(var name: String) {
+  def set(changedName: String) {
+    name = changedName
+  }
+}
+</pre>
+
+Ovaj program nije siguran u multi-thread okruženju. Ako dvije dretve imaju reference na istu instancu Person i zovu @set@, ne možete predvidjeti koji @name@ će biti na kraju oba poziva.
+
+U Java memory modelu, svaki procesor ima dopuštenje spremiti vrijednosti u svoj L1 ili L2 cache kako bi dvije dretve koje se pokreću na različitim procesorima imale svoj pogled na podatke.
+
+Pogledajmo neke alate koji forsiraju dretve da zadrže konzistentan pogled na podatke.
+
+h3. Tri alata
+
+h4. synchronization
+
+Mutex-i pružaju ownership semantiku.  Kada uđete u mutex, posjedujete ga.  Najčešći način korištenja mutex-a u JVM-u je sinkronizacija na nešto.  U ovom slučaju sinkronizirati ćemo nad našom Person.
+
+U JVM-u možete sinkronizirati nad svakom instancom koja nije null.
+
+<pre>
+class Person(var name: String) {
+  def set(changedName: String) {
+    this.synchronized {
+      name = changedName
+    }
+  }
+}
+</pre>
+
+h4. volatile
+
+Sa Java 5 promjenom memory modela, volatile i synchronized su gotovo identični osim što sa volatile, null-ovi su dopušteni.
+
+@synchronized@ dopušta finije zaključavanje.  @volatile@ sinkronizira nad svakim pristupom.
+
+<pre>
+class Person(@volatile var name: String) {
+  def set(changedName: String) {
+    name = changedName
+  }
+}
+</pre>
+
+h4. AtomicReference
+
+Također sa Java 5 je dodan cijeli niz low-level concurrency primitiva. Jedan od njih je @AtomicReference@ klasa.
+
+<pre>
+import java.util.concurrent.atomic.AtomicReference
+
+class Person(val name: AtomicReference[String]) {
+  def set(changedName: String) {
+    name.set(changedName)
+  }
+}
+</pre>
+
+h4. Košta li nas ovo?
+
+@AtomicReference je najskuplji od navedenih izbora budući da morate proći metode kako bi pristupili vrijednostima.
+
+@volatile@ i @synchronized@ su građeni na Java built-in monitorima.  Monitori koštaju malo ako nema konekcija.  Budući da @synchronized@ dopušta finiju kontrolu nad čime sinkronizirate, potrošiti ćemo manje budući da @synchronized@ teži biti najjeftinije rješenje.
+
+Kada uđete u sinkronizirane točke, pristupne volatile reference, ili deferencirane AtomicReference, Java forsira procesor da flush-a svoje cache linije i pruža konzistentan pogled na podatke.
+
+MOLIM VAS, ISPRAVITE ME AKO SAM U KRIVU. Ovo je složena tema i vjerojatno svatko ima svoje mišljenje o tome.
+
+h3. Drugi lipi alati iz Java 5
+
+Kao što smo spomenuli sa @AtomicReference@, Java 5 pruža sjajne alate sa njim.
+
+
+h4. CountDownLatch
+
+@CountDownLatch@ je jednostavan mehanizam za višestruke dretve koji služi za njihovu međusobnu komunikaciju.
+
+<pre>
+val doneSignal = new CountDownLatch(2)
+doAsyncWork(1)
+doAsyncWork(2)
+
+doneSignal.await()
+println("both workers finished!")
+</pre>
+
+Među ostalim, to je odlično za unit testove. Recimo da radite neki asinkronirani posao i želite osigurati da se fukcije izvršavaju. Jednostavno izvršite @countDown@ nad vašim funkcijama i @await@ for it.
+
+h4. AtomicInteger/Long
+
+Budući da je inkrementiranje Int-ova i Long-ova česta operacija dodani su @AtomicInteger@ i @AtomicLong@.
+
+h4. AtomicBoolean
+
+Jasno samo po sebi.
+
+h4. ReadWriteLocks
+
+@ReadWriteLock@ vam dopušta 'hvatanje' reader i writer lock-ova.  reader lock-a samo blok kada je writer lock zauzet.
+
+h2(#example). Kreirajmo nesigurni search engine
+
+Ovdje je jednostavni invert-ani index koji nije thread-safe.  Naš invert-ani index map-ira dijelove imena danog User-a.
+
+Ovo je napisano na naivan način pretpostavljajući samo single-thread pristup.
+
+Primijetite alternativni standardni konstruktor @this()@ koji koristi @mutable.HashMap@
+
+<pre>
+import scala.collection.mutable
+
+case class User(name: String, id: Int)
+
+class InvertedIndex(val userMap: mutable.Map[String, User]) {
+
+  def this() = this(new mutable.HashMap[String, User])
+
+  def tokenizeName(name: String): Seq[String] = {
+    name.split(" ").map(_.toLowerCase)
+  }
+
+  def add(term: String, user: User) {
+    userMap += term -> user
+  }
+
+  def add(user: User) {
+    tokenizeName(user.name).foreach { term =>
+      add(term, user)
+    }
+  }
+}
+</pre>
+
+Izostavili smo kako izvući korisnike iz našeg index-a zasada. O tome kasnije.
+
+h2(#solutions). Napravimo ga sigurnim
+
+U našem inverted index primjeru, userMap nije zasigurno siguran. Više klijenata može pokušati dodati item-e u isto vrijeme i imati isti način pregleda pogrešaka koji smo vidjeli u našem prvom @Person@ primjeru.
+
+Budući da userMap nije thread-safe, kako zadržati samo jednu dretvu kada je mutiramo u isto vrijeme?
+
+Možete pokušati lock-irati na userMap dok dodajete.
+
+<pre>
+def add(user: User) {
+  userMap.synchronized {
+    tokenizeName(user.name).foreach { term =>
+      add(term, user)
+    }
+  }
+}
+</pre>
+
+Nažalost, to je previše sirovo.  Uvijek pokušajte napraviti što više skupog posla izvan mutex-a što je više moguće. Zapamtite što smo rekli kako je lock-anje jeftino kada nema konflikata. Ako napravite više posla unutar bloka, biti će manje konflikata.
+
+<pre>
+def add(user: User) {
+  // tokenizeName was measured to be the most expensive operation.
+  val tokens = tokenizeName(user.name)
+
+  tokens.foreach { term =>
+    userMap.synchronized {
+      add(term, user)
+    }
+  }
+}
+</pre>
+
+h2. SynchronizedMap
+
+Možemo mix-ati sinkronizaciju sa mutabilnom HashMap koristeći SynchronizedMap trait.
+
+Možemo extend-ati naš postojeći InvertedIndex kako bi korisnicima dali jednostavan način kreiranja sinkroniziranog index-a.
+
+
+<pre>
+import scala.collection.mutable.SynchronizedMap
+
+class SynchronizedInvertedIndex(userMap: mutable.Map[String, User]) extends InvertedIndex(userMap) {
+  def this() = this(new mutable.HashMap[String, User] with SynchronizedMap[String, User])
+}
+</pre>
+
+Ako pogledate implementaciju, shvatiti ćete da jednostavno sinkronizira na svakoj metodi, što znači da je sigurno, ali vjerojatno nećete imati performanse koje želite.
+
+h2.  Java ConcurrentHashMap
+
+Java dolazi sa lipom thread-safe ConcurrentHashMap.  Srećom, možemo koristiti JavaConverters kako bi dobili lijepu Scala semantiku.
+
+Zapravo, možemo smisleno raslojiti naš novi, thread-safe InvertedIndex kao ekstenziju nad starim nesigurnim index-om.
+
+<pre>
+import java.util.concurrent.ConcurrentHashMap
+import scala.collection.JavaConverters._
+
+class ConcurrentInvertedIndex(userMap: collection.mutable.ConcurrentMap[String, User])
+    extends InvertedIndex(userMap) {
+
+  def this() = this(new ConcurrentHashMap[String, User] asScala)
+}
+</pre>
+
+h2. Nalodajmo naš InvertedIndex
+
+h3. Naivan način
+
+<pre>
+
+trait UserMaker {
+  def makeUser(line: String) = line.split(",") match {
+    case Array(name, userid) => User(name, userid.trim().toInt)
+  }
+}
+
+class FileRecordProducer(path: String) extends UserMaker {
+  def run() {
+    Source.fromFile(path, "utf-8").getLines.foreach { line =>
+      index.add(makeUser(line))
+    }
+  }
+}
+</pre>
+
+Za svaku liniju u našoj datoteci, zovemo @makeUser@ i zatim ga @add@ našem InvertedIndex-u. Ako koristimo konkuretni InvertedIndex, možemo pozvati add u paraleli i budući da makeUser nema nuspojava (side-effects), to je već thread-safe.
+
+Ne možemo paralelno čitati datoteku ali _možemo_ kreirati User i dodati ga index-u u paraleli.
+
+h3.  Rješenje: Producer/Consumer
+
+Uobičajeni pattern za async komputaciju je odvojiti producers od consumers i dopustiti im komunikaciju samo putem @Queue@.  Pogledajmo kako bi to radilo za naš search engine indexer.
+
+<pre>
+import java.util.concurrent.{BlockingQueue, LinkedBlockingQueue}
+
+// Concrete producer
+class Producer[T](path: String, queue: BlockingQueue[T]) extends Runnable {
+  def run() {
+    Source.fromFile(path, "utf-8").getLines.foreach { line =>
+      queue.put(line)
+    }
+  }
+}
+
+// Abstract consumer
+abstract class Consumer[T](queue: BlockingQueue[T]) extends Runnable {
+  def run() {
+    while (true) {
+      val item = queue.take()
+      consume(item)
+    }
+  }
+
+  def consume(x: T)
+}
+
+val queue = new LinkedBlockingQueue[String]()
+
+// One thread for the producer
+val producer = new Producer[String]("users.txt", q)
+new Thread(producer).start()
+
+trait UserMaker {
+  def makeUser(line: String) = line.split(",") match {
+    case Array(name, userid) => User(name, userid.trim().toInt)
+  }
+}
+
+class IndexerConsumer(index: InvertedIndex, queue: BlockingQueue[String]) extends Consumer[String](queue) with UserMaker {
+  def consume(t: String) = index.add(makeUser(t))
+}
+
+// Let's pretend we have 8 cores on this machine.
+val cores = 8
+val pool = Executors.newFixedThreadPool(cores)
+
+// Submit one consumer per core.
+for (i <- i to cores) {
+  pool.submit(new IndexerConsumer[String](index, q))
+}
+</pre>