fullstack-development · pavelzarubin · Jul 5, 2022 · Apr 21, 2022 · Apr 21, 2022 · Apr 21, 2022
diff --git a/backend/junior-1/haskell.md b/backend/junior-1/haskell.md
@@ -1,6 +1,24 @@
 # Haskell for Junior-1
 
 This level requires basic skills to solve local tasks in a project.
+<details>
+<summary>List of contents</summary>
+
+ - [Functions](#functions)
+ - [Types](#types)
+ - [Lists](#lists)
+ - [Modules](#modules)
+ - [Language control expressions](#language-control-expressions)
+ - [Typeclasses (one parameter)](#typeclasses-one-parameter)
+ - [Monoid](#monoid)
+ - [Functor](#functor)
+ - [Applicative](#applicative)
+ - [Monad](#monad)
+ - [Monad transformers](#monad-transformers)
+ - [Type inference](#type-inference)
+ - [Advanced questions](#advanced-questions)
+
+</details>
 
 ## Functions
 

diff --git a/backend/junior-2/haskell.md b/backend/junior-2/haskell.md
@@ -2,6 +2,24 @@
 
 Advanced questions about Haskell for everyday usage.
 
+<details>
+<summary>List of contents</summary>
+
+- [Modules](#modules)
+- [Typeclasses](#typeclasses)
+- [Applicative](#applicative)
+- [Monads](#monads)
+- [Monoids](#monoids)
+- [Foldable](#foldable)
+- [Traversable](#traversable)
+- [Alternative and MonadPlus](#alternative-and-monadplus)
+- [Deriving and RecordWildCards extensions](#deriving-and-recordwildcards-extensions)
+- [Error management](#error-management)
+- [Service/Handle Pattern](#servicehandle-pattern)
+- [Concurrency](#concurrency)
+</details>
+
+
 ## Modules
 
 * What are cyclic dependencies and what are the methods of resolving them?

diff --git a/backend/junior-2/linux.md b/backend/junior-2/linux.md
@@ -1,5 +1,16 @@
 # Linux administration for junior-2
 
+<details>
+<summary>List of contents</summary>
+
+- [Processes](#processes)
+- [User](#user)
+- [curl](#curl)
+- [Environment](#environment)
+- [Getting help](#getting-help)
+
+ </details>
+
 ## Processes
 
 * How to send a signal to a process? Which signals could be sent?

diff --git a/backend/junior-3/haskell.md b/backend/junior-3/haskell.md
@@ -1,5 +1,23 @@
 # Haskell for Junior-3
 
+<details>
+<summary>List of contents</summary>
+
+- [Type classes](#type-classes)
+- [TypeOperators and type classes extensions](#typeoperators-and-type-classes-extensions)
+- [Type and Data Families](#type-and-data-families)
+- [GADTs](#gadts)
+- [DataKinds](#datakinds)
+- [ScopedTypeVariables, Higher ranked types](#scopedtypevariables-higher-ranked-types)
+- [ExistentialQuantification](#existentialquantification)
+- [Extensions Practice](#extensions-practice)
+- [Laziness](#laziness)
+- [Lists](#lists)
+- [Exceptions](#exceptions)
+- [Debugging](#debugging)
+
+</details>
+
 ## Type classes
 
 * Why using constraints on a type variable within a data declaration isn't a good idea?

diff --git a/backend/middle-1/haskell.md b/backend/middle-1/haskell.md
@@ -1,5 +1,25 @@
 # Haskell for Middle-1
 
+
+<details>
+<summary>List of contents</summary>
+
+- [Basic type classes](#basic-type-classes)
+- [Type classes](#type-classes)
+- [Types](#types)
+- [Polymorphic Kinds](#polymorphic-kinds)
+- [Pattern Synonyms](#pattern-synonyms)
+- [ConstraintKinds](#constraintkinds)
+- [Type inference](#type-inference)
+- [Laziness](#laziness)
+- [Exceptions](#exceptions)
+- [Generics](#generics)
+- [GHCi Debugger](#ghci-debugger)
+- [Lenses](#lenses)
+- [Kata](#kata)
+
+ </details>
+
 ## Basic type classes
 
 * Functors

diff --git a/frontend/junior-1/js.md b/frontend/junior-1/js.md
@@ -1,5 +1,16 @@
 # JavaScript
 
+<details>
+<summary>Содержание</summary>
+
+- [Данные](#данные)
+- [Выражения](#выражения)
+- [Массивы](#массивы)
+- [Функции](#функции)
+- [Прототипы](#прототипы)
+
+ </details>
+
 ## Данные
 
 * Какие типы данных есть в JS?

diff --git a/frontend/junior-3/js.md b/frontend/junior-3/js.md
@@ -1,5 +1,14 @@
 # JavaScript
 
+<details>
+<summary>Содержание</summary>
+
+ - [Регулярные выражения](#регулярные-выражения)
+ - [Promises](#promises)
+ - [Set, Map](#set-map)
+
+ </details>
+
 ## Регулярные выражения
 
 * Что такое регулярные выражения? Когда они могут быть полезны?

diff --git a/frontend/middle-1/algorithmsAndDataStructures.md b/frontend/middle-1/algorithmsAndDataStructures.md
@@ -1,5 +1,14 @@
 # Алгоритмы и структуры данных
 
+<details>
+<summary>Содержание</summary>
+
+ - [Базовые принципы алгоритмизации](#базовые-принципы-алгоритмизации)
+ - [Данные](#данные)
+ - [Алгоритмы](#алгоритмы)
+
+</details>
+
 ## Базовые принципы алгоритмизации
 
 ### Определение

diff --git a/frontend/middle-1/solid.md b/frontend/middle-1/solid.md
@@ -1,5 +1,19 @@
 # SOLID principles
 
+<details>
+  <summary>List of contents</summary>
+
+  - [The Goal](#the-goal)
+  - [The Single Responsibility Principle (SRP)](#the-single-responsibility-principle-srp)
+  - [The Open Closed Principle (OCP)](#the-open-closed-principle-ocp)
+  - [The Liskov Substitution Principle (LSP)](#the-liskov-substitution-principle-lsp)
+  - [The Interface Segregation Principle (ISP)](#the-interface-segregation-principle-isp)
+  - [The Dependency Inversion Principle (DIP)](#the-dependency-inversion-principle-dip)
+  - [SOLID](#solid)
+
+  </details>
+
+
 ## The Goal
 Learn how to design complex systems according to engineering heuristics gathered by R. Martin. The principles are mostly useful for programs written both in OOP and FP paradigms. SOLID is a bright example of not just isolated principles, but the system of checks and balances. In the future you can also learn how to apply the principles for designing high-level architecture too (see Clean Architecture).
 

diff --git a/frontend/middle-3/fp.md b/frontend/middle-3/fp.md
@@ -1,5 +1,19 @@
 # Functional programming
 
+<details>
+ <summary>List of contents</summary>
+
+ - [Closures](#closures)
+ - [Tail call](#tail-call)
+ - [Currying](#currying)
+ - [Point free style](#point-free-style)
+ - [Immutability](#immutability)
+ - [Algebraic Data Types](#algebraic-data-types)
+ - [Combinator library](#combinator-library)
+ - [Common topic resources](#common-topic-resources)
+
+</details>
+
 ## Closures
 * What are free variables?
 * Dynamic scoping