# # Haskell for Junior-1

This level requires basic skills to solve local tasks in a project.

## # Functions

- How to declare a function? What are the function declaration parts?
- What is the type (type signature) of a function?
- Is it possible to declare a function without specifying its type signature? Can it cause problems, and if so, which ones?
- How and when the
`let... in...`

expression is used? - How and when the
`where...`

expression is used? - Function application:
- What is function application operator? And what is its precedence value?
- What is partial application?
- What functions can be applied partially?
- Why there are no function arguments with default values in Haskell?

- Sectioning:
- What is section?
- Which functions could be used in sections?
- Could you use several functions in sections?
- Could you use other than binary functions in sections?

- Function application precedence:
- What are the possible values for precedence in Haskell?
- What is associativity of operators?
- What is associative property? Does function application has that property?
- What are the possible values for associativity in Haskell?
- Why does
`$`

operator exist?

- Function composition:
- How function composition operator is declared? What are its precedence and associativity?
- Is function composition associative?
- What is the associativity of function composition?
Is there some other function in Prelude which operates the same (has the same semantics) as function composition operator
`(.)`

, but has the opposite associativity?

- Recursion
- What is the difference between iterative and recursive algorithms?
- What is a tail recursion?
- What is a tail call optimization? Can you give examples of functions with and without tail call optimization?

## # Types

- What is a type in Haskell? What is a type signature, what could it specify about a type and how it does that?
- What is a type synonym (alias)? When it could be useful? How do you use it?
- Algebraic Data Type:
- Why ADT is called Algebraic? What is a cardinality?
- What are the declaration parts?
- How and why do you use ADTs?
- How and why the record syntax is used? How to extract a value from one of the fields of the corresponding ADT?
- What is recursive data structure? Can you give some examples?

- What is
`newtype`

declaration? Why does it exist? What are its constraints and properties? - Polymorphic types:
- What are polymorphic types and polymorphic functions?
- Examples of polymorphic types and functions.
- What does instantiation of a type variable mean? Does it happen at run time or at compile time?
- Can you put constraints on a type variable within a data declaration?

- What is bottom (
`_|_`

)? - What is kind?

## # Lists

- What are lists in Haskell? What are the distinguishing features of lists from the similar data structures in other languages?
- Name three main functions that work with lists.
- List comprehensions.
- What are infinite lists? What are the use cases of infinite lists?
- Foldings lists:
`foldl`

`foldr`

`foldl1`

,`foldr1`

`foldl'`

,`foldr'`

- Scans:
`scanl`

,`scanr`

, and others. - Examples of using associative and non-associative operators as a folding function. What are the differences between these use cases?
- Does it matter if a folding function has left or right associativity?
- How
`foldl`

,`foldl'`

,`foldr`

and`foldr'`

behave with infinite lists, and why do they have the particular behavior? - When
`foldl'`

does not solve the problem of deferring too many calculations? - Which fold functions support short-circuit (lazy) evaluation?

## # Modules

- Module declaration.
- How can you import modules (all different ways)?
- How to solve name conflicts?
- Qualified import.
- Import hiding some names.

- Export:
Is it possible to export only a part of declared names in a module?

How to export functions, operators?

How to export ADT without constructor; with several constructors; with all constructors?

How to export type synonym?

How to export imported module?

How to export constructors

`Just`

,`Nothing`

and function`fromMaybe`

in the following example?`module A(?) where import qualified Data.Maybe as Mb`

What will be exported in this case:

`module External ( module Internal ) where import qualified Internal`

What are cyclic dependencies and what are the methods of resolving them?

## # Language control expressions

`if.. then... else...`

expression.`case... of...`

expression.- Guards in a function declaration.
- Pattern matching.
- How to pattern match on parts of the string?

## # Typeclasses (one parameter)

- What are typeclasses?
- Why do we use them?
- What is a superclass? How to define a superclass relation?
- Standard typeclasses:
`Eq`

,`Ord`

`Show`

,`Read`

`Enum`

`Bounded`

- What are the numeric typeclasses in Haskell? What are their relations?

- What is ad-hoc polymorphism and what are the alternatives?
- How to specify a typeclass in a type signature?
- How to make default function implementation? Is it possible to specify the type of default implementation to be distinct from declared typeclass method?
- What are orphan instances? What is coherence and why is it important to maintain it? What are the possible cases of coherence violation?
- What is instance deriving? When is it possible to derive an instance?

## # Basic functional programming patterns (and their laws)

- Functor.
- Applicative.
- Alternative and MonadSum.
- Monoid.
- How Monoid and Alternative differ conceptually?

## # Monad

- What is a Monad as a programming pattern and as an entity?
- Monad typeclass methods:
`return`

.`bind`

.`join`

.- Implement
`bind`

from`join`

and backwards. - What is Kleisli arrow (category)?
- Monad laws.

- Basic monads list:
`Maybe`

.`Either`

.`List`

.`Reader`

.`Writer`

.`State`

.`IO`

.

`do`

-notation.- How does Monad differ from Functor and Applicative?
- Error management strategies:
- How do
`Maybe`

and`Either`

help with error management? - How to use
`try`

,`catch`

and`throw`

functions? - Can
`throw`

and`catch`

be called in pure functions? - What is the difference between
`throw`

and`throwIO`

functions?

- How do
- How to use the following functions?
`filterM`

`foldM`

`forM`

`mapM`

`liftM`

## # Monad transformers

- What is
`lift`

function? - What is
`liftIO`

function? - What are
`MonadTrans`

laws? - What transformer is used with
`Either`

? - How to use
`IO`

monad in a transformer stack? - Is there a difference between using
`MaybeT (StateT IO) ()`

and`StateT (MaybeT IO) ()`

?

## # Type inference

- What does type inference mean?
- Basic concepts of Hindley-Milner type inference.
- How we can get following problems while types inferring? How to solve them?
- Ambiguity.
- Deducing problem.
- Matching problem.
- Infinite type problem:
- What’s result of computation
`let t = [t] in t`

? How to explain this behavior?

- What’s result of computation

## # Lazy evaluation

- What is the difference between laziness and non-strictness? What is the difference between eager and strict evaluation?
- What is a redex?
- What is outside in and inside out evaluation?
- What is lazy evaluation?
- How it differs from eager evaluation? What are the pros and cons of lazy evaluation?
- Is Haskell a lazy language?
- What is thunk?
- Describe the concept of its inner structure.
- Could you think of cases when thunk occupies less space than the evaluated value and visa versa?
- Can you nest thunks?

- What is the difference between call by value, call by name and call by need?
- What is WHNF?
- Are next expressions in WHNF or NF?
`(*) (2 + 2)`

`thunk`

`1:(thunk)`

`1:2:(thunk)`

`1:2:3:[]`

`15`

`\x -> x * 2`

`(\x -> x + 1) 3`

- Why strict functions in Haskell evaluate values to WHNF and not NF?

### # Resources

- Functions:
- Types:
- Sections:
- Function application and composition:
- Folds:
- Modules:
- Lazy evaluation:
- Monads:
- Exceptions: