jupyter/First.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let f x = 1 + x\n",
    "f 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "module PipelinesAndComposition =\n",
    "\n",
    "    /// Squares a value.\n",
    "    let square x = x * x\n",
    "\n",
    "    /// Adds 1 to a value.\n",
    "    let addOne x = x + 1\n",
    "\n",
    "    /// Tests if an integer value is odd via modulo.\n",
    "    let isOdd x = x % 2 <> 0\n",
    "\n",
    "    /// A list of 5 numbers.  More on lists later.\n",
    "    let numbers = [ 1; 2; 3; 4; 5 ]\n",
    "\n",
    "    /// Given a list of integers, it filters out the even numbers,\n",
    "    /// squares the resulting odds, and adds 1 to the squared odds.\n",
    "    let squareOddValuesAndAddOne values = \n",
    "        let odds = List.filter isOdd values\n",
    "        let squares = List.map square odds\n",
    "        let result = List.map addOne squares\n",
    "        result\n",
    "\n",
    "    printfn \"processing %A through 'squareOddValuesAndAddOne' produces: %A\" numbers (squareOddValuesAndAddOne numbers)\n",
    "    \n",
    "    /// A shorter way to write 'squareOddValuesAndAddOne' is to nest each\n",
    "    /// sub-result into the function calls themselves.\n",
    "    ///\n",
    "    /// This makes the function much shorter, but it's difficult to see the\n",
    "    /// order in which the data is processed.\n",
    "    let squareOddValuesAndAddOneNested values = \n",
    "        List.map addOne (List.map square (List.filter isOdd values))\n",
    "\n",
    "    printfn \"processing %A through 'squareOddValuesAndAddOneNested' produces: %A\" numbers (squareOddValuesAndAddOneNested numbers)\n",
    "\n",
    "    /// A preferred way to write 'squareOddValuesAndAddOne' is to use F# pipe operators.\n",
    "    /// This allows you to avoid creating intermediate results, but is much more readable\n",
    "    /// than nesting function calls like 'squareOddValuesAndAddOneNested'\n",
    "    let squareOddValuesAndAddOnePipeline values =\n",
    "        values\n",
    "        |> List.filter isOdd\n",
    "        |> List.map square\n",
    "        |> List.map addOne\n",
    "\n",
    "    printfn \"processing %A through 'squareOddValuesAndAddOnePipeline' produces: %A\" numbers (squareOddValuesAndAddOnePipeline numbers)\n",
    "\n",
    "    /// You can shorten 'squareOddValuesAndAddOnePipeline' by moving the second `List.map` call\n",
    "    /// into the first, using a Lambda Function.\n",
    "    ///\n",
    "    /// Note that pipelines are also being used inside the lambda function.  F# pipe operators\n",
    "    /// can be used for single values as well.  This makes them very powerful for processing data.\n",
    "    let squareOddValuesAndAddOneShorterPipeline values =\n",
    "        values\n",
    "        |> List.filter isOdd\n",
    "        |> List.map(fun x -> x |> square |> addOne)\n",
    "\n",
    "    printfn \"processing %A through 'squareOddValuesAndAddOneShorterPipeline' produces: %A\" numbers (squareOddValuesAndAddOneShorterPipeline numbers)\n",
    "\n",
    "    /// Lastly, you can eliminate the need to explicitly take 'values' in as a parameter by using '>>'\n",
    "    /// to compose the two core operations: filtering out even numbers, then squaring and adding one.\n",
    "    /// Likewise, the 'fun x -> ...' bit of the lambda expression is also not needed, because 'x' is simply\n",
    "    /// being defined in that scope so that it can be passed to a functional pipeline.  Thus, '>>' can be used\n",
    "    /// there as well.\n",
    "    ///\n",
    "    /// The result of 'squareOddValuesAndAddOneComposition' is itself another function which takes a\n",
    "    /// list of integers as its input.  If you execute 'squareOddValuesAndAddOneComposition' with a list\n",
    "    /// of integers, you'll notice that it produces the same results as previous functions.\n",
    "    ///\n",
    "    /// This is using what is known as function composition.  This is possible because functions in F#\n",
    "    /// use Partial Application and the input and output types of each data processing operation match\n",
    "    /// the signatures of the functions we're using.\n",
    "    let squareOddValuesAndAddOneComposition =\n",
    "        List.filter isOdd >> List.map (square >> addOne)\n",
    "\n",
    "    printfn \"processing %A through 'squareOddValuesAndAddOneComposition' produces: %A\" numbers (squareOddValuesAndAddOneComposition numbers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PipelinesAndComposition.square 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2; 3]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1; 2; 3;] |> List.filter (fun x -> x > 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let f x = x + 1\n",
    "let g x = x * x\n",
    "let h = f >> g\n",
    "h 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "F#",
   "language": "fsharp",
   "name": "ifsharp"
  },
  "language": "fsharp",
  "language_info": {
   "codemirror_mode": "",
   "file_extension": ".fs",
   "mimetype": "text/x-fsharp",
   "name": "fsharp",
   "nbconvert_exporter": "",
   "pygments_lexer": "",
   "version": "4.3.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}