{ "metadata": { "language": "haskell", "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![](https://raw2.github.com/gibiansky/IHaskell/master/images/ihaskell-logo-small.png)\n", "\n", "IHaskell Notebook\n", "===\n", "Hello, and welcome to the **IHaskell Notebook**. IHaskell Notebook is similar to an interactive shell along the lines of GHCi. However, it is much more powerful, and provides features such as syntax highlighting, autocompletion, multi-line input cells, integrated documentation, rich output visualization, and more. In this notebook, I'd like to demonstrate many of the awesome features IHaskell provides.\n", "\n", "IHaskell is implemented as a language kernel for the [IPython](http://ipython.org) project, which means that although the entire thing is written only in Haskell, we get a beautiful notebook interface practically for free.\n", "\n", "We can start with very simple Haskell expressions:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- First of all, we can evaluate simple expressions.\n", "3 + 5\n", "\"Hello, \" ++ \"World!\"" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "8" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "\"Hello, World!\"" ] } ], "prompt_number": 1 }, { "cell_type": "markdown", "metadata": {}, "source": [ "As you can see, each input cell get an execution number. The first input cell is labeled `In [1]`. Just like in GHCi, the output of the last executed statement or expression is available via the `it` variable - however, in addition, the output of the $n$th cell is available via the `itN` variable. For example, if we wanted to see what the first cell printed, we can go ahead and output that:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "it1" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "\"Hello, World!\"" ] } ], "prompt_number": 2 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to simple code cells such as the ones you see, you can also have other types of cells. All of this inline text, for instance, is written using Markdown cells, which support the majority of Github markdown syntax. This lets you embed images and formatting and arbitrary HTML interspersed with your Haskell code. In addition, you can export these notebooks into HTML or even as presentations using `reveal.js`. \n", "\n", "Alright, back to code. Let's do something slightly fancier:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- Unlike in GHCi, we can have multi-line expressions.\n", "concat [\n", " \"Hello\",\n", " \", \",\n", " \"World!\"\n", " ] :: String" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "\"Hello, World!\"" ] } ], "prompt_number": 3 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to multi-line expressions, IHaskell supports most things that you could put in a standard Haskell file. For example, we can have function bindings without the `let` that GHCi requires. (As long as you group type signatures and their corresponding declarations together, you can use pattern matching and put signatures on your top-level declarations!)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "thing :: String -> Int -> Int\n", "thing \"no\" _ = 100\n", "thing str int = int + length str\n", "\n", "thing \"no\" 10\n", "thing \"ah\" 10" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "100" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "12" ] } ], "prompt_number": 4 }, { "cell_type": "markdown", "metadata": {}, "source": [ "So far we've just looked at pure functions, but nothing is stopping us from doing IO." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print \"What's going on?\"" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "\"What's going on?\"" ] } ], "prompt_number": 5 }, { "cell_type": "markdown", "metadata": {}, "source": [ "IHaskell supports most GHC extensions via the `:extension` directive (or any shorthand thereof)." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- We can disable extensions.\n", ":ext NoEmptyDataDecls\n", "data Thing" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "`Thing' has no constructors (-XEmptyDataDecls permits this)
In the data declaration for `Thing'
" ], "metadata": {}, "output_type": "display_data", "text": [ "`Thing' has no constructors (-XEmptyDataDecls permits this)\n", "In the data declaration for `Thing'" ] } ], "prompt_number": 6 }, { "cell_type": "code", "collapsed": false, "input": [ "-- And enable extensions.\n", ":ext EmptyDataDecls\n", "data Thing" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 7 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Data declarations do pretty much what you expect, and work fine on multiple lines. If a declaration turns out to be not quite what you wanted, you can just go back, edit it, and re-evaluate the code cell." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- Various data declarations work fine.\n", "data One\n", " = A String\n", " | B Int\n", " deriving Show\n", "\n", "print [A \"Hello\", B 10]" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "[A \"Hello\",B 10]" ] } ], "prompt_number": 8 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Although this doesn't hold everywhere, we've tried to keep IHaskell relatively similar to GHCi in terms of naming. So, just like in GHCi, you can inspect types with `:type` (or shorthands):" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- We can look at types like in GHCi.\n", ":ty 3 + 3" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "forall a. Num a => a" ], "metadata": {}, "output_type": "display_data", "text": [ "forall a. Num a => a" ] } ], "prompt_number": 9 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The same goes for the `:info` command. However, unlike GHCi, which simply prints info, the IHaskell notebook brings up a separate pane." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- What is the Integral typeclass?\n", ":info Integral" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data" } ], "prompt_number": 10 }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you're looking at this notebook after it's been exported to HTML, you won't be able to see this interactive pane. However, it looks approximately like this:\n", "\n", "![](https://raw2.github.com/gibiansky/IHaskell/master/demo/info-demo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now write slightly more complicated scripts." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- Results are printed as we go, even from a single expression.\n", "import Control.Monad\n", "import Control.Concurrent\n", "\n", "forM_ [1..5] $ \\x -> do\n", " print x\n", " threadDelay $ 200 * 1000" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "1\n", "2\n", "3\n", "4\n", "5" ] } ], "prompt_number": 11 }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is where the similarities with GHCi end, and the particularly shiny features of IHaskell begin.\n", "\n", "Although looking at text outputs is often enough, there are many times where we really want a richer output. Suppose we have a custom data type for color:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "data Color = Red | Green | Blue" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 12 }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we were playing around with designing GUI applications, for instance, we might want to actually *see* these colors, instead of just seeing the text \"Red\", \"Green\", and \"Blue\" when we are debugging.\n", "\n", "IHaskell lets you define a custom display mechanism for any data type via its `IHaskellDisplay` typeclass. Since you can use IHaskell in console mode as well as notebook mode, you can provide a list of display outputs for any data type, and the frontend will simply choose the best one. Here's how you would implement a very simple display mechanism for this `Color` data type:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import IHaskell.Display\n", "\n", "instance IHaskellDisplay Color where\n", " display color = return $ Display [html code]\n", " where\n", " code = concat [\"
Look!
\"]\n", " css Red = \"red\"\n", " css Blue = \"blue\"\n", " css Green = \"green\"" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 13 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once we define a custom `display :: a -> IO Display` function, we can simply output a `Color`:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "Red\n", "Green\n", "Blue" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "
Look!
" ], "metadata": {}, "output_type": "display_data" }, { "html": [ "
Look!
" ], "metadata": {}, "output_type": "display_data" }, { "html": [ "
Look!
" ], "metadata": {}, "output_type": "display_data" } ], "prompt_number": 14 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `DisplayData` type has several constructors which let you display your data as plain text, HTML, images (SVG, PNG, JPG), or even as LaTeX code.\n", "\n", "In order to ship an extension for IHaskell, simply create a package named `ihaskell-thing` with a module named `IHaskell.Display.Thing`. As long as `ihaskell-thing` is installed, IHaskell will detect and use it automatically.\n", "\n", "A number of packages already exist, which we can briefly look at. First, in `ihaskell-basic`, we have very simple displays for data types from `Prelude`." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- We can display Maybes fancily for Show-able types.\n", "Just ()\n", "Nothing\n", "\n", "-- But it dies if it's not showable.\n", "data NoShow = X Int\n", "Just (X 3)" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "Just()" ], "metadata": {}, "output_type": "display_data", "text": [ "Just ()" ] }, { "html": [ "Nothing" ], "metadata": {}, "output_type": "display_data", "text": [ "Nothing" ] }, { "html": [ "
Unshowable:NoShowNo instance for (Show NoShow) arising from a use of `print'
Possible fix: add an instance declaration for (Show NoShow)
In a stmt of an interactive GHCi command: print it
" ], "metadata": {}, "output_type": "display_data", "text": [ "No instance for (Show NoShow) arising from a use of `print'\n", "Possible fix: add an instance declaration for (Show NoShow)\n", "In a stmt of an interactive GHCi command: print it" ] } ], "prompt_number": 15 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `ihaskell-aeson` package adds a display for [Aeson](http://hackage.haskell.org/package/aeson) JSON `Value` types. These are automatically syntax highlighted and formatted nicely." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- Aeson JSON data types are displayed nicely.\n", ":ext OverloadedStrings\n", "\n", "import Data.Aeson\n", "\n", "data Coord = Coord { x :: Double, y :: Double }\n", "instance ToJSON Coord where\n", " toJSON (Coord x y) = object [\"x\" .= x, \"y\" .= y]\n", "\n", "Null\n", "Bool True\n", "toJSON (Coord 3 2)" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "
null
" ], "metadata": {}, "output_type": "display_data", "text": [ "null" ] }, { "html": [ "
true
" ], "metadata": {}, "output_type": "display_data", "text": [ "true" ] }, { "html": [ "
{\n", " \"x\": 3,\n", " \"y\": 2\n", "}
" ], "metadata": {}, "output_type": "display_data", "text": [ "{\n", " \"x\": 3,\n", " \"y\": 2\n", "}" ] } ], "prompt_number": 16 }, { "cell_type": "markdown", "metadata": {}, "source": [ "This syntax highlighting may not show up in the exported HTML, as it is done on the fly with Javascript. The result looks like this in the notebook:\n", "\n", "![](https://raw2.github.com/gibiansky/IHaskell/master/demo/json-demo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `ihaskell-blaze` package lets you play around with HTML straight from within IHaskell using the [Blaze](http://jaspervdj.be/blaze/tutorial.html) library." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- Small bits of HTML generated via Blaze are displayed.\n", "\n", "import Prelude hiding (div, id)\n", "import Text.Blaze.Html4.Strict hiding (map, style)\n", "import Text.Blaze.Html4.Strict.Attributes\n", "\n", "div ! style \"color: red\" $ do\n", " p \"This is an example of BlazeMarkup syntax.\"\n", " b \"Hello\"\n", " \n", "forM [1..5] $ \\size -> do\n", " let s = toValue $ size * 70\n", " img ! src \"https://www.google.com/images/srpr/logo11w.png\" ! width s" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "
\n", "

\n", " This is an example of BlazeMarkup syntax.\n", "

\n", " \n", " Hello\n", " \n", "
\n" ], "metadata": {}, "output_type": "display_data", "text": [ "
\n", "

\n", " This is an example of BlazeMarkup syntax.\n", "

\n", " \n", " Hello\n", " \n", "
" ] }, { "html": [ "\n", "\n", "\n", "\n", "\n" ], "metadata": {}, "output_type": "display_data", "text": [ "\n", "\n", "\n", "\n", "" ] } ], "prompt_number": 17 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `ihaskell-diagrams` package allows you to experiment with the [diagrams](http://projects.haskell.org/diagrams/) package. It requires the Cairo backend." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- We can draw diagrams, right in the notebook.\n", ":extension NoMonomorphismRestriction\n", "import Diagrams.Prelude\n", "\n", "-- By Brent Yorgey\n", "-- Draw a Sierpinski triangle!\n", "sierpinski 1 = eqTriangle 1\n", "sierpinski n = s\n", " ===\n", " (s ||| s) # centerX\n", " where s = sierpinski (n-1)\n", "\n", "-- The `diagram` function is used to display them in the notebook.\n", "diagram $ sierpinski 4\n", " # centerXY\n", " # fc black\n", " `atop` square 10\n", " # fc white" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "" ], "metadata": {}, "output_type": "display_data", "text": [] } ], "prompt_number": 21 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Just like with Diagrams, `ihaskell-charts` allows you to use the [Chart](https://github.com/timbod7/haskell-chart/wiki) library for plotting from within IHaskell. (You will need to install `cairo` as well, which may be a bit of a hassle.)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- We can draw small charts in the notebook.\n", "-- This example is taken from the haskell-chart documentation.\n", "import Graphics.Rendering.Chart \n", "import Data.Default.Class\n", "import Control.Lens\n", "\n", "let values = [\n", " (\"Mexico City\" , 19.2, 0),\n", " (\"Mumbai\" , 12.9, 10), \n", " (\"Sydney\" , 4.3, 0),\n", " (\"London\" , 8.3, 0), \n", " (\"New York\" , 8.2, 25)]\n", " \n", "pitem (s, v, o) = pitem_value .~ v\n", " $ pitem_label .~ s\n", " $ pitem_offset .~ o\n", " $ def \n", "\n", "-- Convert to a renderable in order to display it.\n", "toRenderable \n", " $ pie_title .~ \"Relative Population\"\n", " $ pie_plot . pie_data .~ map pitem values\n", " $ def" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "" ], "metadata": {}, "output_type": "display_data", "png": "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" } ], "prompt_number": 19 }, { "cell_type": "markdown", "metadata": {}, "source": [ "By default, both `ihaskell-diagrams` and `ihaskell-chart` use SVG displays. However, the notebook does not support interactive resizing for SVG image. However, if you use `:set no-svg`, all SVG outputs will instead be shown as PNG images, and they can be resized easily." ] }, { "cell_type": "code", "collapsed": false, "input": [ ":opt no-svg\n", "\n", "toRenderable \n", " $ pie_title .~ \"Relative Population\"\n", " $ pie_plot . pie_data .~ map pitem values\n", " $ def" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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" } ], "prompt_number": 20 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, the `ihaskell-magic` chart uses the [magic](http://hackage.haskell.org/package/magic) library (bindings to `libmagic`) to create a display mechanism for `ByteString`s. If you try to load an image, for instance, you will see that image immediately in the notebook." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import qualified Data.ByteString as B\n", "B.readFile \"code/IHaskell/images/ihaskell-notebook.png\"" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "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" } ], "prompt_number": 21 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to displaying outputs in a rich format, IHaskell has a bunch of useful features.\n", "\n", "For instance, the popular linting tool `hlint` is integrated and turned on by default. Let's write some ugly code, and see what it tells us:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- There is also hlint integration enabled by default.\n", "-- If you write sketchy code, it will tell you:\n", "f :: Int -> Int\n", "f x = x + 1\n", "\n", "-- Most warnings are orange...\n", "f $ 3\n", "\n", "-- But more severe warnings are red.\n", "putStrLn (show 3)\n", "do\n", " return 3" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "
Redundant $
Found:
f $ 3\n", "
Why Not:
f 3\n", "
Use print
Found:
putStrLn (show 3)\n", "
Why Not:
print 3\n", "
Redundant do
Found:
do return 3\n", "
Why Not:
return 3\n", "
" ], "metadata": {}, "output_type": "display_data", "text": [ "Line 7: Redundant $\n", "Found:\n", " f $ 3\n", "\n", "Why not:\n", " f 3\n", "Line 10: Use print\n", "Found:\n", " putStrLn (show 3)\n", "\n", "Why not:\n", " print 3\n", "Line 11: Redundant do\n", "Found:\n", " do return 3\n", "\n", "Why not:\n", " return 3" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "4" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "3" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "3" ] } ], "prompt_number": 22 }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you're an experienced Haskeller, though, and don't want `hlint` telling you what to do, you can easily turn it off:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- If hlint annoys you, though, you can turn it off.\n", "-- Note that this only takes effect in the next cell execution.\n", ":opt no-lint" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 23 }, { "cell_type": "code", "collapsed": false, "input": [ "-- You could similarly use `:opt lint` to turn it back on.\n", "f $ 3" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "4" ] } ], "prompt_number": 24 }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to `hlint` integration, IHaskell also integrates **Hoogle** for documentation searches. IHaskell provides two directives for searching Hoogle. The first of these, `:document` (or shorthands), looks for exact matches." ] }, { "cell_type": "code", "collapsed": false, "input": [ ":doc filterM" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data" } ], "prompt_number": 25 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like with `:info`, the Hoogle directives use the IPython documentation pager to show you their output. You can press Escape to dismiss the pager. If you're reading this in it's HTML form, the output looks like this:\n", "\n", "![](https://raw2.github.com/gibiansky/IHaskell/master/demo/doc-demo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The other provided command is `:hoogle`. This does a normal Hoogle search, and thus lets you use imperfect matching and searching by type signature." ] }, { "cell_type": "code", "collapsed": false, "input": [ ":hoogle :: [a] -> [(a, b)]" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data" } ], "prompt_number": 26 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The pager will show you documentation for things that could have that type signature or a similar one. It automatically formats inline Haskell code and hyperlinks the identifiers to their respective Haddock documentations:\n", "\n", "![](https://raw2.github.com/gibiansky/IHaskell/master/demo/hoogle-demo.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you need a refresher on all of the options, you can just use `:help`:" ] }, { "cell_type": "code", "collapsed": false, "input": [ ":help" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "The following commands are available:\n", " :extension - Enable a GHC extension.\n", " :extension No - Disable a GHC extension.\n", " :type - Print expression type.\n", " :info - Print all info for a name.\n", " :hoogle - Search for a query on Hoogle.\n", " :doc - Get documentation for an identifier via Hogole.\n", " :set -XFlag -Wall - Set an option (like ghci).\n", " :option - Set an option.\n", " :option no- - Unset an option.\n", " :?, :help - Show this help text.\n", "\n", "Any prefix of the commands will also suffice, e.g. use :ty for :type.\n", "\n", "Options:\n", " lint - enable or disable linting.\n", " svg - use svg output (cannot be resized).\n", " show-types - show types of all bound names\n", " show-errors - display Show instance missing errors normally." ] } ], "prompt_number": 27 }, { "cell_type": "markdown", "metadata": {}, "source": [ "All of the code you normally put into IHaskell is (like in GHCi) interpreted. However, sometimes you've perfected a function, and now need it to run faster. In that case, you can go ahead and define a module in a single cell. As long as your module has a module header along the lines of `module Name where`, IHaskell will recognize it as a module. It will create the file `A/B.hs`, compile it, and load it. " ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- If your code isn't running fast enough, you can just put it into a module.\n", "module A.B where\n", "\n", "fib 0 = 1\n", "fib 1 = 1\n", "fib n = fib (n-1) + fib (n-2)" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 28 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the module is by default imported unqualified, as though you had typed `import A.B`." ] }, { "cell_type": "code", "collapsed": false, "input": [ "-- The module is automatically imported unqualified.\n", "print $ A.B.fib 20\n", "print $ fib 20" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "10946" ] }, { "metadata": {}, "output_type": "display_data", "text": [ "10946" ] } ], "prompt_number": 29 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that since a new module is imported, all previous bound identifiers are now unbound. For instance, we no longer have access to the `f` function from before:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "f 3" ], "language": "python", "metadata": {}, "outputs": [ { "html": [ "Not in scope: `f'" ], "metadata": {}, "output_type": "display_data", "text": [ "Not in scope: `f'" ] } ], "prompt_number": 30 }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, if you re-import this module with another import statement, the original implicit import goes away." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import qualified A.B as Fib\n", "\n", "Fib.fib 20\n", "fib 20" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "text": [ "10946" ] }, { "html": [ "Not in scope: `fib'
Perhaps you meant `Fib.fib' (imported from A.B)
" ], "metadata": {}, "output_type": "display_data", "text": [ "Not in scope: `fib'\n", "Perhaps you meant `Fib.fib' (imported from A.B)" ] } ], "prompt_number": 31 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Thanks!\n", "---\n", "\n", "That's it for now! I hope you've enjoyed this little demo of **IHaskell**! There are still a few features that I haven't covered, such as the `show-types` and `show-errors` options, as well as the relatively intelligent autocompletion mechanism and inline type info popups.\n", "\n", "I hope you find IHaskell useful, and please report any bugs or features requests [on Github](https://github.com/gibiansky/IHaskell/issues). If you have any comments, want to contribute, or just want to get in touch, don't hesitate to contact me at Andrew dot Gibiansky at Gmail. Contributions are also more than welcome, and I'm happy to help you get started with IHaskell development if you'd like to contribute!\n", "\n", "I am also often available at `#ihaskell` on IRC at `chat.freenode.net`, so if I'm around, don't hesitate to ask questions.\n", "\n", "Thank you to [Adam Vogt](https://github.com/aavogt), [Stian H\u00e5klev](http://reganmian.net/), and [@edechter](https://github.com/edechter) for their testing, bug reporting, pull requests, and general patience!" ] } ], "metadata": {} } ] }