Ruby things I done did learn about and such

I gave a short presentation in work on some interesting things I've learnt about in Ruby recently.

There was a whole lot more I could've spoken about on these topics but this was a nice overview.

Transcript

1. Ruby things I done did learn about and such
2. Former trees
3. What we’ll chat about • Ampersand operator and blocks of code • Enumerators and the Enumerable module • Ruby Object Model: singleton methods and the like
4. Ampersand operator and blocks When & is prepended to the last parameter in a method definition and the method is called with a block then the block is saved in this variable.
5. :block_given? You can use :block_given? to check if a block has been supplied to stop nasty errors.
6. Sidenote, you can call callable objects with the .() syntax
7. Yielding to blocks You can use the yield keyword to yield to a given block.
8. Passing Procs and Lambdas to methods If you have a Proc or a Lambda saved in a variable then you can use & to turn it into a code block and pass it to a method.
9. The super magical wonder syntax Many people who are not familiar with Ruby are often mystified by this syntax.
10. & == :to_proc Appending an ‘&’ to an object will call :to_proc on that object. So what does :to_proc do?
11. Symbol#to_proc The last slide works because of some majestic code like this
12. Hash#to_proc Many classes in Ruby already have :to_proc defined. Hash#to_proc can be used to run multiple lookups in one go
13. You can define your own version of :to_proc and use ‘&’ until the cows come home. Whatever makes you happy really.
14. Moving on, I needed to know why this works
15. Why? How? Explain yourself, heathen.
16. Because enumerators.
17. But first, Enumerable! If you define a method called :each in your class and include the Enumerable module you get all sorts of methods for free. Enumerable uses :each in your class as the basis for its lovely methods.
18. There are methods defined in the Enumerable module which when called without a block will return an enumerator. • :map • :each • :select • :cycle There are plenty of others.
19. This is recreation of what Enumerable#map does.
20. That’s cool but what the dickens is an enumerator?
21. From ruby-doc.org “A class which allows both internal and external iteration.”
22. An enumerator will use the code of whichever method it’s based on as its :each method. 1st line — :each returns an enumerator that uses Array’s :each method code for its :each method, so a call to :map after works as normal. 2nd line — :map returns an enumerator that uses Array’s :map method code for its :each, so the call to :each is technically just a call to :map.
23. Enumerator has some cool tricks. You can step through your values and :rewind back to the start. You can :peek at upcoming values without moving your internal iterator.
24. Don’t iterate too far though.
25. Use :cycle for that :cycle will iterate to the end then start from the beginning again. No errors, no mess, no fuss. Good clean iterative fun for all the family.
26. Simple encryption with an enumerator
27. Ruby Object Model: deliciously simple/simply delicious
28. Method lookup
29. me Skip :hello Object BasicObject Calling :hello Right into the object’s class then up chain of superclasses. Because :hello is found in Skip that method is then run.
30. me Skip Object BasicObject :method_missing Calling :shout We go right into the object’s class, there is no method called :shout so we move up the chain to Object. We reach BasicObject without having found it, so :method_missing is called on the original receiver (me) and we follow the process again. This means you can override :method_missing in your classes if you so wish.
31. Singleton methods Ruby lets you add methods directly to an object. These methods end up in what’s known as the object’s Singleton Class.
32. me Skip Object BasicObject Calling :shout singleton method #me :shout Right into the object’s singleton class then up into the object’s class, then up into the class’s superclass etc.
33. Class methods Because a class is, like everything else, just an object you can define methods on them too. There are a couple of other ways you can define class methods though...
34. Or you could do it this way But why repeat your class name? that’s going to be a pain if you end up changing it. Keep things DRY™.
35. Seeing as you already have the class open you have access to self. This is the most common way you’ll see class methods defined.
36. The tastiest way “class << self” will open the singleton class and you can define them in there.
37. me Skip Object BasicObject Calling the Skip :hello class method #me #Skip :hello #Object #BasicObject Right from the Skip class into its singleton class, then up into the superclass’s singleton class, and so on. This is a simplified object model without modules, but if you understand this then you’re golden.
38. And yes, singleton class have singleton classes. Those have singleton classes too...
39. In a nutshell “The superclass of the singleton class of an object is the object’s class. The superclass of the singleton class of a class is the singleton class of the class’s superclass”
40. fin