Add Blocks section to Tutorials

[ftarulla]

In this PR we add an intro to Blocks in the Methods section and continue in a Blocks section.

We talked about:

• Blocks definition
• Blocks and methods
• Blocks with parameters
• Returning keywords
• Type restrictions
• Alternative syntaxes
• Under the hood

[netlify]

✅ Deploy Preview for crystal-book ready!

Name	Link
🔨 Latest commit	90637ac
🔍 Latest deploy log	https://app.netlify.com/sites/crystal-book/deploys/63b4e3df72fdd3000876c9da
😎 Deploy Preview	https://deploy-preview-655--crystal-book.netlify.app
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.

---

To edit notification comments on pull requests, go to your Netlify site settings.

[beta-ziliani]

I didn't check it entirely because I have a high-level point that probably needs addressing. I find the example a bit convoluted, probably because it's artificial. Maybe consider using the loop toplevel method? This could be good to explain when to skip (next) and when to break.

For instance:

# print even numbers from 0 to 10

i = 0
loop do
	i += 1
  next if i % 2 == 1
	p i
  break if i == 10
end

The example doesn't need to be the same from top to bottom. The important bit is that it can be described easily as I did above, to help understanding that it does (and why is important to learn).

[straight-shoota]

This content is quite a lot and hardly fits into the Methods lesson (which doubles in size). I'd suggest to introduce it as a separate lesson called Blocks in order to keep every single one at a reasonable length.
I would also separate captures into a later lessen called Procs. The section about capatured blocks is very short and incomplete. There are a lot more aspects as well as a lot more complexity involved with closures and procs. It's an entire topic on its own and should come later in the tutorial after generics are introduced (and possibly some other concepts).

Regarding blocks, there are also some more aspects that need to be addressed. Not all of them are essential to be fully fleshed out right away, but should be covered eventually.
I think a good order of introduction could look like this:

• Basics: yield + do ... end
  • Explain the purpose and benefit of blocks, plus demonstrate the effect of inlining
  • multiple yield
  • specifics of overloading
• output values (without keywords)
• parameters
  • including underscore, omission, splats and unpacking
  • types
• keywords
  • next
  • break
  • return
• block type restrictions
• alternative call syntaxes:
  • curly braces
  • short block notation

The language specification already covers a lot of that and we can copy ideas from there, adapted to a tutorial format.

[beta-ziliani]

Don't be alarm by the amount of comments, there are mostly nitpickings :-)

[beta-ziliani]

Since there's nothing in the method that suggest a 42, what about this name instead?

Suggested change

	def with_42
	yield
	end
	with_42 do
	puts 42
	end
	def run
	yield
	end
	run do
	puts 42
	end

[beta-ziliani]

Just if the previous comment is accepted:

Suggested change

	def three_times
	yield
	yield
	yield
	end
	three_times do
	puts 42
	end
	def run_three_times
	yield
	yield
	yield
	end
	run_three_times do
	puts 42
	end

[beta-ziliani]

A real nitpick.

Suggested change

	Here are two examples:
	Consider the following two examples:

[beta-ziliani]

Suggested change

Unpacking arguments into parameters works only if the argument's type responds to `[i]` (with `i` an `integer`). In our example `Array` inherits [Indexable#[ ]](https://crystal-lang.org/api/Indexable.html#%5B%5D%28index%3AInt%29-instance-method)

Unpacking arguments into parameters works only if the argument's type responds to `[i]` (with `i` an `integer`). In our example `Array` inherits [Indexable#[ ]](https://crystal-lang.org/api/Indexable.html#%5B%5D%28index%3AInt%29-instance-method). Of course, it will raise an exception if we try to unpack more elements than existing. You can try it yourself, by adding a parameter or by removing an element.

[beta-ziliani]

Suggested change

	`Tuples` also implements [Tuple#[ ]](https://crystal-lang.org/api/Tuple.html#%5B%5D%28index%3AInt%29-instance-method) meaning that we can also use *unpacking*.
	`Tuples` also implements [Tuple#[ ]](https://crystal-lang.org/api/Tuple.html#%5B%5D%28index%3AInt%29-instance-method) meaning that we can also use *unpacking*. But there's a difference in how unpacking or auto-splatting works with tuples when there aren't sufficient elements. Try it, can you spot the difference?

[beta-ziliani]

Suggested change

	First we split the block parameter using the *short one-parameter syntax* `&.split`. Then, we chained the result applying `map` and using again the *short one-parameter syntax* `.map(&.capitalize)`. And finally we join the `array` of `strings` using `join(' ')`.
	First we split the block parameter using the *short one-parameter syntax* `&.split`. Then, we chained the result applying `map` and using again the short one-parameter syntax `.map(&.capitalize)`. And finally we join the `array` of `strings` using `join(' ')`.

[beta-ziliani]

Suggested change

	Now, what if we want to parameterize the string we transform. Can we still use the *short one-parameter syntax*? The answer is yes! Let's see:
	Now, what if we want to parameterize the string we transform. Can we still use the short one-parameter syntax? The answer is yes! Let's see:

[beta-ziliani]

Suggested change

	Before finishing this section of the tutorial, it would be a good idea to see how *blocks* work under the hood.
	Before finishing this section of the tutorial, it would be a good idea to see how blocks work under the hood.

[beta-ziliani]

Suggested change

	First, it's important to note that in this section we have only seen *blocks* that we use with the keyword `yield`. There is [another kind of block](../../syntax_and_semantics/capturing_blocks.md), but we will leave it for later in the tutorial.
	First, it's important to note that in this section we have only seen blocks that we use with the keyword `yield`. There is [another kind of block](../../syntax_and_semantics/capturing_blocks.md), but we will leave it for later in the tutorial.

[beta-ziliani]

Suggested change

	In a method that receives a *block*, when we write `yield`, the compiler will inline the *block of code*, which means that this:
	In a method that receives a block, when we write `yield`, the compiler will inline the block of code, which means that this: