Reduced contents of introduction.md

concepts/map/introduction.md

@@ -16,20 +16,4 @@ Let's see another example where we greet a given person with the message "Welcom
   (str "Welcome " name "!"))
 
 (map say-welcome ["Chris" "Jane" "Peter"]) ; => ("Welcome Chris!" "Welcome Jane!" "Welcome Peter!")
-```
-
-## Returning a lazy sequence
-
-Previously we provided a simplified explanation of how `map` operates. In reality, `map` returns a so-called *lazy* sequence. Although an explanation of lazy sequences goes beyond the scope of this introduction, it basically means that the elements of the resulting list are not generated until they are actually needed. In other words, it is not until we actually use elements of this list (e.g., to print them or retrieve their value) that the function `f` passed to `map` is applied to generate each element. This is advantageous when `f` is computationally expensive and we end-up only needing to retrieve some of the elements of the resulting list later in the program. 
-
-## Using multiple collections
-
-`map` allows multiple collections to be passed as input. If the number of collections we pass is `n`, the function `f` will receive `n` elements, one for each collection in the list. The result is a list where the i-th element is obtained by applying `f` to the i-th element of each collection:
-
-```clojure
-(def coll_a [a1 a2])
-(def coll_b [b1 b2])
-(def coll_c [c1 c2])
-(map f coll_a coll_b coll_c) ; => ((f a1 b1 c1) (f a2 b2 c2))
-```
-
+```

concepts/reduce/introduction.md

@@ -42,16 +42,4 @@ In the previous example, the function `include-if-even` accepts two arguments: a
 ;=> [2 4] 
 ```
 
-Note that in the previous example we must necessarily pass three arguments to `reduce`: our function `include-if-even`, an initial collection `[]`, and a collection of numbers like `[1 2 3 4]`. The initial collection `[]` is necessary due to the fact that `include-if-even` needs it as its first argument.
-
-## Especial cases
-
-Especial cases arise when we use an empty collection or a collection with only one item:
-
-- If we apply `reduce` to an empty collection, `(reduce f val coll)` returns `(f val)`, and `(reduce f coll)` returns the result of applying `f` with no arguments. In this case, the function `f` must be able to use no arguments. 
-- If we apply `reduce` to a collection with only one item, `(reduce f val coll)` returns `(f val x_1)`, i.e., the result of applying `f` to `val` and the first element `x_1` of `coll`. If used with only two arguments, `(f coll)` returns the only element found in `coll`, and `f` is not called.
-
-## Using collections of functions
-
-`reduce` accepts any type of collection, including one that contains functions. In that case, we will typically use three arguments `(reduce f val coll)`, and the function `f` applies the first function `g_1` from the collection to `val`, then the second function `g_2` to the result of the previous application, `(f (f val g_1) g_2)` and so on until all the functions are applied. 
-
+Note that in the previous example we must necessarily pass three arguments to `reduce`: our function `include-if-even`, an initial collection `[]`, and a collection of numbers like `[1 2 3 4]`. The initial collection `[]` is necessary due to the fact that `include-if-even` needs it as its first argument.