Typo

Author: dumindu

content/en/docs/e6.combinators.md

@@ -5,38 +5,38 @@ slug: combinators
 
 ## What is a combinator?
 
-- One meaning of “combinator” is a more informal sense referring to the **combinator pattern**, a style of organizing libraries centered around the idea of combining things. Usually there is **some type T**, some **functions for constructing “primitive” values of type T**, and some “**combinators**” which can **combine values of type T** in various ways to **build up more complex values of type T**. The other definition is **"function with no free variables"**.
+- One meaning of “combinator” is a more informal sense referring to the combinator pattern, a style of organizing libraries centered around the idea of combining things. Usually there is some type T, some functions for constructing “primitive” values of type T, and some “combinators” which can combine values of type T in various ways to build up more complex values of type T. The other definition is "function with no free variables".
 __ [wiki.haskell.org](https://wiki.haskell.org/Combinator)
 
-- A combinator is **a function** which **builds program fragments from program fragments**; in a sense the programmer using combinators constructs much of the desired program automatically, rather that writing every detail by hand. 
+- A combinator is a function which builds program fragments from program fragments; in a sense the programmer using combinators constructs much of the desired program automatically, rather that writing every detail by hand. 
 __ John Hughes—[Generalizing Monads to Arrows](http://www.cse.chalmers.se/~rjmh/Papers/arrows.pdf) via [Functional Programming Concepts](https://github.com/caiorss/Functional-Programming/blob/master/haskell/Functional_Programming_Concepts.org)
 
 The exact definition of "combinators" in Rust ecosystem is bit unclear. 
 
 - `or()`, `and()`, `or_else()`, `and_then()`
-  - **Combine two values of type T** and **return same type T**.
+  - Combine two values of type T and return same type T.
 
 - `xor()` for `Option` types
-  - **Combine two values of type T** and **return same type T**, **only if exactly one value is T**
+  - Combine two values of type T and return same type T, only if exactly one value is T
 
 - `filter()` for `Option` types
-  - **Filter type T** by using a closure as a conditional function
-  - **Return same type T**
+  - Filter type T by using a closure as a conditional function
+  - Return same type T
 
 - `map()`, `map_err()`
-  - **Convert type T by applying a closure**.
-  - The **data type of the value inside T can be changed**.
+  - Convert type T by applying a closure.
+  - The data type of the value inside T can be changed.
     ex. `Some<&str>` can be converted to `Some<usize>` or `Err<&str>` to `Err<isize>` and etc.
 
 - `map_or()`, `map_or_else()`
-  - **Transform type T by applying a closure** & **return the value inside type T**.
-  - For **`None` and `Err`, a default value or another closure** is applied.
+  - Transform type T by applying a closure & return the value inside type T.
+  - For `None` and `Err`, a default value or another closure is applied.
 
 - `ok_or()`, `ok_or_else()` for `Option` types
-  - **Transform `Option` type into a `Result` type**.
+  - Transform `Option` type into a `Result` type.
 
 - `as_ref()`, `as_mut()`
-  - **Transform type T into a reference or a mutable reference**.
+  - Transform type T into a reference or a mutable reference.
 
 ## or() and and()
 
@@ -101,7 +101,7 @@ assert_eq!(n.xor(n), n); // None1 xor None2 = None2
 
 ## or_else()
 
-Similar to `or()`. The only difference is, the second expression should be a **[closure](/docs/functions/#closures)** which returns same type T.
+Similar to `or()`. The only difference is, the second expression should be a [closure](/docs/functions/#closures) which returns same type T.
 
 ### With Option
 
@@ -138,7 +138,7 @@ assert_eq!(e1.or_else(fn_err), e2); // Err1 or_else Err2 = Err2
 
 ## and_then()
 
-Similar to `and()`. The only difference is, the second expression should be a **[closure](/docs/functions/#closures)** which returns same type T.
+Similar to `and()`. The only difference is, the second expression should be a [closure](/docs/functions/#closures) which returns same type T.
 
 ### With Option
 
@@ -176,7 +176,7 @@ assert_eq!(e1.and_then(fn_err), e1); // Err1 and_then Err2 = Err1
 ## filter()
 
 > [!tip]
-> Usually in programming languages `filter` functions are used with arrays or iterators to create a new array/ iterator by filtering own elements via a function/ closure. Rust also provides [`filter()` **as an iterator adaptor**](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter) to apply a closure on each element of an iterator to transform it into another iterator. However in here we are talking about the functionality of `filter()` with `Option` types.
+> Usually in programming languages `filter` functions are used with arrays or iterators to create a new array/ iterator by filtering own elements via a function/ closure. Rust also provides [`filter()` as an iterator adaptor](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter) to apply a closure on each element of an iterator to transform it into another iterator. However in here we are talking about the functionality of `filter()` with `Option` types.
 
 The same `Some` type is returned, only if we pass a `Some` value and the given closure returned true for it. `None` is returned, if `None` type passed or the closure returned false. The closure uses the value inside `Some` as an argument. Still Rust support `filter()` only for `Option` types.
 
@@ -195,9 +195,9 @@ assert_eq!(n.filter(fn_is_even), n);   // None -> no value -> None
 ## map() and map_err()
 
 > [!tip]
-> Usually in programming languages `map()` functions are used with arrays or iterators, **to apply a closure on each element** of the array or iterator. Rust also provides [`map()` **as an iterator adaptor**](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map) to apply a closure on each element of an iterator to transform it into another iterator. However in here we are talking about the functionality of `map()` with `Option` and `Result` types.
+> Usually in programming languages `map()` functions are used with arrays or iterators, to apply a closure on each element of the array or iterator. Rust also provides [`map()` as an iterator adaptor](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map) to apply a closure on each element of an iterator to transform it into another iterator. However in here we are talking about the functionality of `map()` with `Option` and `Result` types.
 
-- `map()` : Convert type T by applying a closure. **The data type of `Some` or `Ok` blocks can be changed** according to the return type of the closure. Convert `Option<T>` to `Option<U>`, `Result<T, E>` to `Result<U, E>`
+- `map()` : Convert type T by applying a closure. The data type of `Some` or `Ok` blocks can be changed according to the return type of the closure. Convert `Option<T>` to `Option<U>`, `Result<T, E>` to `Result<U, E>`
 
 ⭐ Via `map()`, only `Some` and `Ok` values are getting changed. No affect to the values inside `Err` (`None` doesn’t contain any value at all).
 
@@ -231,7 +231,7 @@ assert_eq!(o1.map(fn_character_count), o2); // Ok1 map = Ok2
 assert_eq!(e1.map(fn_character_count), e2); // Err1 map = Err2
 ```
 
-- `map_err()` for `Result` types : **The data type of `Err` blocks can be changed** according to the return type of the closure. Convert `Result<T, E>` to `Result<T, F>`.
+- `map_err()` for `Result` types : The data type of `Err` blocks can be changed according to the return type of the closure. Convert `Result<T, E>` to `Result<T, F>`.
 
 ⭐ Via `map_err()`, only `Err` values are getting changed. No affect to the values inside `Ok`.
 
@@ -250,7 +250,7 @@ assert_eq!(e1.map_err(fn_character_count), e2); // Err1 map = Err2
 
 ## map_or() and map_or_else()
 
-Hope you remember the functionality of [`unwrap_or()` and `unwrap_or_else()`](/docs/unwrap-and-expect/#unwrap_or-unwrap_or_default-and-unwrap_or_else) functions. These functions also bit similar to them. But `map_or()` and `map_or_else()` apply a closure on `Some` and `Ok` values and **return the value inside type T**.
+Hope you remember the functionality of [`unwrap_or()` and `unwrap_or_else()`](/docs/unwrap-and-expect/#unwrap_or-unwrap_or_default-and-unwrap_or_else) functions. These functions also bit similar to them. But `map_or()` and `map_or_else()` apply a closure on `Some` and `Ok` values and return the value inside type T.
 
 - `map_or()` : Support only for `Option` types (not supporting `Result`). Apply the closure to the value inside `Some` and return the output according to the closure. The given default value is returned for `None` types.
 
@@ -293,7 +293,7 @@ assert_eq!(e.map_or_else(fn_default_for_result, fn_closure), 6);
 
 ## ok_or() and ok_or_else()
 
-As mentioned earlier, `ok_or()`, `ok_or_else()` transform `Option` type into `Result` type. **`Some` to `Ok` and `None` to `Err`**.
+As mentioned earlier, `ok_or()`, `ok_or_else()` transform `Option` type into `Result` type. `Some` to `Ok` and `None` to `Err`.
 
 - `ok_or()` : A default `Err` message should pass as argument.
 
@@ -326,7 +326,7 @@ assert_eq!(n.ok_or_else(fn_err_message), e); // None -> Err(default)
 
 ## as_ref() and as_mut()
 
-🔎 As mentioned earlier, these functions are used to **borrow type T as a reference or as a mutable reference**.
+🔎 As mentioned earlier, these functions are used to borrow type T as a reference or as a mutable reference.
 
 - `as_ref()` : Convert `Option<T>` to `Option<&T>` and `Result<T, E>` to `Result<&T, &E>`
 - `as_mut()` : Converts `Option<T>` to `Option<&mut T>` and `Result<T, E>` to `Result<&mut T, &mut E>`