ch16-functional-programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functional programming (Chap 16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pure functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Immutability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Higher-order functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# method chains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Kernel#itself, Kernel#yield_self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# functions that return functions\n",
    "\n",
    "def multiply_by(m)\n",
    "    Proc.new {|x| puts x*m}\n",
    "end\n",
    "\n",
    "mult = multiply_by(10)\n",
    "mult.call(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Proc:0x000055db38771578 (pry):15 (lambda)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# currying & partial function application\n",
    "# -- functions are called with #functions less than its arity.\n",
    "# -- function is eval'd; returns new function that takes rest of args.\n",
    "\n",
    "add = -> (a,b) {a+b}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SyntaxError: unexpected integer literal, expecting ')'\n",
      "add = -> (1, b) { 1 + b }\n",
      "          ^\n"
     ]
    }
   ],
   "source": [
    "add = -> (1, b) { 1 + b }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Proc:0x000055db386f1058 (pry):18 (lambda)>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# currying: return series of functions, each taking one argument.\n",
    "add = -> (a,b) { -> (b) {a+b}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, 3, 6, 9, 12]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# curry does both partial application & currying.\n",
    "# use case: generic, reusable functions\n",
    "\n",
    "def find_multiples_of_3(arr)\n",
    "    arr.select {|e1| e1 % 3 == 0}\n",
    "end\n",
    "\n",
    "def find_multiples_of_5(arr)\n",
    "    arr.select {|e1| e1 % 5 == 0}\n",
    "end\n",
    "\n",
    "find_multiples_of_3([-3,3,4,5,6,8,9,10,12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_multiples_of_5([-3,3,4,5,6,8,9,10,12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Proc:0x000055db383a7c80 (lambda)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# abstracting out one argument:\n",
    "find_multiples = -> (x,arr) {arr.select {|el| el % x == 0 }}\n",
    "\n",
    "# curried form - pass one arg, return func that takes remaining arg.\n",
    "find_multiples_of = find_multiples.curry\n",
    "\n",
    "find_multiples_of_3 = find_multiples_of.(3)\n",
    "find_multiples_of_5 = find_multiples_of.(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, 3, 6, 9, 12]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_multiples_of_3([-3,3,4,5,6,8,9,10,12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 10]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_multiples_of_5([-3,3,4,5,6,8,9,10,12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lazy evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tail-call optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"well-grounded-rubyist.ipynb\\n\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`ls *.ipynb`"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.7.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}