From c628bdf959394468f7a42dd5ea16c10028ee2cf8 Mon Sep 17 00:00:00 2001
From: klntsky <klntsky@gmail.com>
Date: Fri, 20 Sep 2019 22:32:53 +0300
Subject: [PATCH] Add packages to the search index (#16) Sort search results by
 popularity (based on number of package reverse dependencies).

---
 CHANGELOG.md                                  |   8 +-
 src/Docs/Search/App.purs                      |   7 +-
 src/Docs/Search/App/SearchField.purs          |   3 +-
 src/Docs/Search/App/SearchResults.purs        | 139 +++++++++++-------
 .../Search/{Index.js => BrowserEngine.js}     |   0
 .../Search/{Index.purs => BrowserEngine.purs} |  53 +++++--
 src/Docs/Search/Config.purs                   |  19 ++-
 src/Docs/Search/Declarations.purs             |  56 ++++---
 src/Docs/Search/DocsJson.purs                 |   6 +
 src/Docs/Search/Engine.purs                   | 126 +++++++++++-----
 src/Docs/Search/Extra.purs                    |  10 +-
 src/Docs/Search/IndexBuilder.purs             |  75 +++++-----
 src/Docs/Search/Interactive.purs              | 101 +++++++------
 src/Docs/Search/NodeEngine.purs               |  55 +++++++
 src/Docs/Search/PackageIndex.js               |  24 +++
 src/Docs/Search/PackageIndex.purs             | 128 ++++++++++++++++
 src/Docs/Search/SearchResult.purs             |  19 +--
 src/Docs/Search/TypeIndex.purs                |  43 +++---
 src/Docs/Search/TypePrinter.purs              |  26 +++-
 src/Docs/Search/TypeQuery.purs                |  17 ++-
 src/Docs/Search/TypeShape.purs                |  10 +-
 test/Test/TypeQuery.purs                      |  45 +++++-
 22 files changed, 703 insertions(+), 267 deletions(-)
 rename src/Docs/Search/{Index.js => BrowserEngine.js} (100%)
 rename src/Docs/Search/{Index.purs => BrowserEngine.purs} (72%)
 create mode 100644 src/Docs/Search/NodeEngine.purs
 create mode 100644 src/Docs/Search/PackageIndex.js
 create mode 100644 src/Docs/Search/PackageIndex.purs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fdfe92c..2c1369e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,7 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 New features:
 - Render docs as markdown (#15)
-- Show help for each CLI command.
+- Show help for each CLI command (#17)
+- Add packages to the search index (#16)
+- Sort search results by popularity (based on number of package reverse dependencies).
+
+Bugfixes:
+- Fix decoding of kind annotations in `forall`s (#17)
+- Fix rendering for variable-parametrized records (e.g. `Record a`) and type-level strings.
 
 ## [0.0.4] - 2019-07-25
 
diff --git a/src/Docs/Search/App.purs b/src/Docs/Search/App.purs
index d402ee5..dd5ded0 100644
--- a/src/Docs/Search/App.purs
+++ b/src/Docs/Search/App.purs
@@ -6,6 +6,7 @@ import Prelude
 import Docs.Search.App.SearchField as SearchField
 import Docs.Search.App.SearchResults as SearchResults
 import Docs.Search.Extra (whenJust)
+import Docs.Search.PackageIndex as PackageIndex
 
 import Control.Coroutine as Coroutine
 import Data.Maybe (Maybe(..))
@@ -38,8 +39,12 @@ main = do
 
   whenJust mbContainers \ { searchField, searchResults, pageContents } -> do
     HA.runHalogenAff do
+      packageIndex <- PackageIndex.loadPackageIndex
+
+      let initialSearchEngineState = { packageIndex: packageIndex, index: mempty, typeIndex: mempty }
+
       sfio <- runUI SearchField.component unit searchField
-      srio <- runUI (SearchResults.mkComponent pageContents markdownIt) unit searchResults
+      srio <- runUI (SearchResults.mkComponent initialSearchEngineState pageContents markdownIt) unit searchResults
       sfio.subscribe $
         Coroutine.consumer (srio.query <<< H.tell <<< SearchResults.MessageFromSearchField)
 
diff --git a/src/Docs/Search/App/SearchField.purs b/src/Docs/Search/App/SearchField.purs
index 1a37fed..70433c2 100644
--- a/src/Docs/Search/App/SearchField.purs
+++ b/src/Docs/Search/App/SearchField.purs
@@ -20,7 +20,7 @@ import Web.DOM.ParentNode as ParentNode
 import Web.HTML (window) as Web
 import Web.HTML as HTML
 import Web.HTML.HTMLDocument as HTMLDocument
-import Web.HTML.HTMLElement (blur) as Web
+import Web.HTML.HTMLElement (blur, focus) as Web
 import Web.HTML.HTMLInputElement as HTMLInputElement
 import Web.HTML.Window (document) as Web
 import Web.HTML.Window as Window
@@ -74,6 +74,7 @@ handleAction = case _ of
       when (not state.focused) do
         H.liftEffect do
           withSearchField HTMLInputElement.select
+          withSearchField (HTMLInputElement.toHTMLElement >>> Web.focus)
 
     when (KE.code ev == "Escape") do
       state <- H.get
diff --git a/src/Docs/Search/App/SearchResults.purs b/src/Docs/Search/App/SearchResults.purs
index 150642b..a79f494 100644
--- a/src/Docs/Search/App/SearchResults.purs
+++ b/src/Docs/Search/App/SearchResults.purs
@@ -1,22 +1,25 @@
 -- | This module contains a Halogen component for search results.
 module Docs.Search.App.SearchResults where
 
-import Prelude
-
 import Docs.Search.App.SearchField (SearchFieldMessage(..))
+import Docs.Search.BrowserEngine (PartialIndex, browserSearchEngine)
 import Docs.Search.Config (config)
 import Docs.Search.Declarations (DeclLevel(..), declLevelToHashAnchor)
 import Docs.Search.DocsJson (DataDeclType(..))
-import Docs.Search.Extra ((>#>), homePageFromRepository)
+import Docs.Search.Extra (homePageFromRepository, (>#>))
+import Docs.Search.PackageIndex (PackageResult)
+import Docs.Search.Engine (Result(..))
+import Docs.Search.Engine as Engine
 import Docs.Search.SearchResult (ResultInfo(..), SearchResult(..))
 import Docs.Search.TypeDecoder (Constraint(..), FunDep(..), FunDeps(..), Kind(..), QualifiedName(..), Type(..), TypeArgument(..), joinForAlls, joinRows)
-import Docs.Search.Engine as SearchEngine
-import Docs.Search.Engine (ResultsType(..))
+import Docs.Search.TypeIndex (TypeIndex)
+
+import Prelude
 
 import Data.Array ((!!))
 import Data.Array as Array
 import Data.List as List
-import Data.Maybe (Maybe(..), isJust)
+import Data.Maybe (Maybe(..), isJust, fromMaybe)
 import Data.Newtype (wrap)
 import Data.String.CodeUnits (stripSuffix) as String
 import Data.String.Common (null, trim) as String
@@ -40,9 +43,12 @@ data Mode = Off | Loading | Active
 derive instance eqMode :: Eq Mode
 
 
-type State = { searchEngineState :: SearchEngine.State
-             , results :: Array SearchResult
-             , resultsType :: ResultsType
+type EngineState =
+  Engine.EngineState PartialIndex TypeIndex
+
+
+type State = { engineState :: EngineState
+             , results :: Array Result
              , input :: String
              , contents :: Element
              , resultsCount :: Int
@@ -62,14 +68,14 @@ data Action
 
 mkComponent
   :: forall o i
-  .  Element
+  .  EngineState
+  -> Element
   -> MD.MarkdownIt
   -> H.Component HH.HTML Query i o Aff
-mkComponent contents markdownIt =
+mkComponent initialEngineState contents markdownIt =
   H.mkComponent
-    { initialState: const { searchEngineState: mempty
+    { initialState: const { engineState: initialEngineState
                           , results: []
-                          , resultsType: DeclResults
                           , input: ""
                           , contents
                           , resultsCount: config.resultsCount
@@ -107,12 +113,14 @@ handleQuery (MessageFromSearchField (InputUpdated input_) next) = do
     H.modify_ (_ { mode = Loading, resultsCount = config.resultsCount })
 
     void $ H.fork do
-      { searchEngineState, results, resultsType } <- H.liftAff $
-        SearchEngine.query state.searchEngineState state.input
+      { index, results } <- H.liftAff $
+        Engine.query browserSearchEngine state.engineState state.input
+
       H.modify_ (_ { results = results
                    , mode = Active
-                   , searchEngineState = searchEngineState
-                   , resultsType = resultsType })
+                   , engineState = index
+                   }
+                )
 
     hidePageContents
 
@@ -186,15 +194,6 @@ render state@{ mode: Active } =
   renderContainer $
   [ HH.h1_ [ HH.text "Search results" ]
 
-  , HH.div [ HP.classes [ wrap "result" ] ] $
-    [ HH.text "Found "
-    , HH.strong_ [ HH.text $ show $ Array.length state.results ]
-    , HH.text $
-        case state.resultsType of
-          DeclResults   -> " definitions."
-          TypeResults _ -> " definitions with similar types."
-    ]
-
   , HH.div_ $
     Array.concat $ shownResults <#> renderResult state.markdownIt
 
@@ -227,11 +226,49 @@ renderSummary text =
 
 
 renderResult
+  :: forall a
+  .  MD.MarkdownIt
+  -> Result
+  -> Array (HH.HTML a Action)
+renderResult markdownIt (DeclResult sr) = renderSearchResult markdownIt sr
+renderResult markdownIt (TypeResult sr) = renderSearchResult markdownIt sr
+renderResult markdownIt (PackResult sr) = renderPackageResult sr
+
+
+renderPackageResult
+  :: forall a
+  .  PackageResult
+  -> Array (HH.HTML a Action)
+renderPackageResult { name, description, repository } =
+  [ HH.div [ HP.class_ (wrap "result") ]
+    [ HH.h3 [ HP.class_ (wrap "result__title") ]
+      [ HH.span [ HP.classes [ wrap "result__badge"
+                             , wrap "badge"
+                             , wrap "badge--package" ]
+                , HP.title "Package"
+                ]
+        [ HH.text "P" ]
+
+      , HH.a [ HP.class_ (wrap "result__link")
+             , HP.href $ fromMaybe "" repository # homePageFromRepository
+             ]
+        [ HH.text name ]
+      ]
+    ]
+  ] <>
+
+  description >#> \descriptionText ->
+  [ HH.div [ HP.class_ (wrap "result__body") ]
+    [ HH.text descriptionText ]
+  ]
+
+
+renderSearchResult
   :: forall a
   .  MD.MarkdownIt
   -> SearchResult
   -> Array (HH.HTML a Action)
-renderResult markdownIt (SearchResult result) =
+renderSearchResult markdownIt (SearchResult result) =
   -- class names here and below are from Pursuit.
   [ HH.div [ HP.class_ (wrap "result") ]
     [ HH.h3 [ HP.class_ (wrap "result__title") ]
@@ -274,30 +311,6 @@ renderResult markdownIt (SearchResult result) =
     ]
   ]
 
-renderResult _markdownIt (PackageResult { name, description, repository }) =
-  [ HH.div [ HP.class_ (wrap "result") ]
-    [ HH.h3 [ HP.class_ (wrap "result__title") ]
-      [ HH.span [ HP.classes [ wrap "result__badge"
-                             , wrap "badge"
-                             , wrap "badge--package" ]
-                , HP.title "Package"
-                ]
-        [ HH.text "P" ]
-
-      , HH.a [ HP.class_ (wrap "result__link")
-             , HP.href $ homePageFromRepository repository
-             ]
-        [ HH.text name ]
-      ]
-    ]
-  ] <> (
-    description >#>
-    \descriptionText ->
-    [ HH.div [ HP.class_ (wrap "result__body") ]
-      [ HH.text descriptionText ]
-    ]
-  )
-
 
 renderResultType
   :: forall a rest
@@ -476,7 +489,7 @@ renderType
   -> HH.HTML a Action
 renderType = case _ of
   TypeVar str -> HH.text str
-  TypeLevelString str -> HH.text $ "(Text \"" <> str <> "\")" -- TODO: add escaping
+  TypeLevelString str -> HH.text $ "\"" <> str <> "\"" -- TODO: add escaping
   TypeWildcard -> HH.text "_"
   TypeConstructor qname -> renderQualifiedName false TypeLevel qname
   TypeOp qname -> renderQualifiedName true TypeLevel qname
@@ -569,7 +582,17 @@ renderRow asRow =
 
   if List.null rows
   then
-    [ HH.text $ if asRow then "()" else "{}" ]
+    [ if asRow
+      then HH.text "()"
+      else
+        fromMaybe (HH.text "{}") $
+        ty <#> \ty' ->
+        HH.span_
+        [ renderQualifiedName false TypeLevel primRecord
+        , HH.text " "
+        , renderType ty'
+        ]
+    ]
   else
     [ HH.text opening ] <>
 
@@ -579,9 +602,9 @@ renderRow asRow =
                  , renderType entry.ty ] ]
     ) <>
 
-    case ty of
-      Just ty' -> [ HH.text " | ", renderType ty', HH.text closing ]
-      Nothing  -> [ HH.text closing ]
+    (ty >#> \ty' -> [ HH.text " | ", renderType ty' ]) <>
+
+    [ HH.text closing ]
 
     where
       opening = if asRow then "( " else "{ "
@@ -643,6 +666,10 @@ makeHref level isInfix moduleName name =
   if isInfix then "type (" <> name <> ")" else name
 
 
+primRecord :: QualifiedName
+primRecord = QualifiedName { moduleName: [ "Prim" ], name: "Record" }
+
+
 keyword
   :: forall a
   .  String
diff --git a/src/Docs/Search/Index.js b/src/Docs/Search/BrowserEngine.js
similarity index 100%
rename from src/Docs/Search/Index.js
rename to src/Docs/Search/BrowserEngine.js
diff --git a/src/Docs/Search/Index.purs b/src/Docs/Search/BrowserEngine.purs
similarity index 72%
rename from src/Docs/Search/Index.purs
rename to src/Docs/Search/BrowserEngine.purs
index 93d0297..a79fc64 100644
--- a/src/Docs/Search/Index.purs
+++ b/src/Docs/Search/BrowserEngine.purs
@@ -1,17 +1,20 @@
--- | Contains `Index` that can be loaded on demand, transparently
--- | to the user.
-module Docs.Search.Index where
-
-import Prelude
+-- | A search engine that is used in the browser.
+module Docs.Search.BrowserEngine where
 
 import Docs.Search.Config (config)
+import Docs.Search.PackageIndex (queryPackageIndex)
+import Docs.Search.Engine (Engine, EngineState, Index)
 import Docs.Search.SearchResult (SearchResult)
+import Docs.Search.TypeIndex (TypeIndex)
+import Docs.Search.TypeIndex as TypeIndex
+
+import Prelude
 
+import Data.Char as Char
 import Control.Promise (Promise, toAffE)
 import Data.Argonaut.Core (Json)
 import Data.Argonaut.Decode (decodeJson)
 import Data.Array as Array
-import Data.Char as Char
 import Data.Either (hush)
 import Data.List (List, (:))
 import Data.List as List
@@ -26,22 +29,27 @@ import Data.Tuple (Tuple(..))
 import Effect (Effect)
 import Effect.Aff (Aff, try)
 
-newtype Index
-  = Index (Map Int (Trie Char (List SearchResult)))
 
-derive instance newtypeIndex :: Newtype Index _
-derive newtype instance semigroupIndex :: Semigroup Index
-derive newtype instance monoidIndex :: Monoid Index
+newtype PartialIndex
+  = PartialIndex (Map Int Index)
+
+derive instance newtypePartialIndex :: Newtype PartialIndex _
+derive newtype instance semigroupPartialIndex :: Semigroup PartialIndex
+derive newtype instance monoidPartialIndex :: Monoid PartialIndex
+
+
+type BrowserEngineState = EngineState PartialIndex TypeIndex
+
 
 -- | This function dynamically injects a script with the required index part and returns
--- | a new `Index` that contains newly loaded definitions.
+-- | a new `PartialIndex` that contains newly loaded definitions.
 -- |
 -- | We split the index because of its size, and also to speed up queries.
 query
-  :: Index
+  :: PartialIndex
   -> String
-  -> Aff { index :: Index, results :: Array SearchResult }
-query index@(Index indexMap) input = do
+  -> Aff { index :: PartialIndex, results :: Array SearchResult }
+query index@(PartialIndex indexMap) input = do
   let
     path :: List Char
     path =
@@ -70,7 +78,7 @@ query index@(Index indexMap) input = do
 
       case mbNewTrie of
         Just newTrie -> do
-          pure { index: Index $ Map.insert partId newTrie indexMap
+          pure { index: PartialIndex $ Map.insert partId newTrie indexMap
                , results: flatten $ Trie.queryValues path newTrie
                }
         Nothing -> do
@@ -79,6 +87,7 @@ query index@(Index indexMap) input = do
   where
     flatten = Array.concat <<< Array.fromFoldable <<< map Array.fromFoldable
 
+
 insertResults
   :: Tuple String (Array SearchResult)
   -> Trie Char (List SearchResult)
@@ -96,6 +105,17 @@ insertResults (Tuple path newResults) =
         Nothing  -> Just $ List.fromFoldable newResults
         Just old -> Just $ List.fromFoldable newResults <> old
 
+
+browserSearchEngine
+  :: Engine Aff PartialIndex TypeIndex
+browserSearchEngine =
+  { queryIndex: query
+  , queryTypeIndex: TypeIndex.query
+  , queryPackageIndex
+  }
+
+
+
 -- | Find in which part of the index this path can be found.
 getPartId :: List Char -> Int
 getPartId (a : b : _) =
@@ -104,6 +124,7 @@ getPartId (a : _) =
   Char.toCharCode a `mod` config.numberOfIndexParts
 getPartId _ = 0
 
+
 -- | Load a part of the index by injecting a <script> tag into the DOM.
 foreign import loadIndex_
  :: Int
diff --git a/src/Docs/Search/Config.purs b/src/Docs/Search/Config.purs
index bc9043d..bf5c4cb 100644
--- a/src/Docs/Search/Config.purs
+++ b/src/Docs/Search/Config.purs
@@ -5,9 +5,10 @@ import Prelude
 -- | Some magic constants.
 config ::
   { declIndexDirectory :: String
-  , indexDirectory :: String
   , mkIndexPartLoadPath :: Int -> String
   , mkIndexPartPath :: Int -> String
+  , packageInfoPath :: String
+  , packageInfoLoadPath :: String
   , mkShapeScriptPath :: String -> String
   , numberOfIndexParts :: Int
   , outputDirectory :: String
@@ -28,20 +29,24 @@ config =
   { outputDirectory: "output"
   , requiredDirectories:
     [ "generated-docs"
+    , "generated-docs/html"
     , "output"
     ]
   -- ^ Directories required by IndexBuilder
-  , indexDirectory: "generated-docs/index"
-  , declIndexDirectory: "generated-docs/index/declarations"
-  , typeIndexDirectory: "generated-docs/index/types"
+  , declIndexDirectory: "generated-docs/html/index/declarations"
+  , typeIndexDirectory: "generated-docs/html/index/types"
   , mkShapeScriptPath:
-    \shape -> "../index/types/" <> shape <> ".js"
+    \shape -> "./index/types/" <> shape <> ".js"
   , numberOfIndexParts: 50
   -- ^ In how many parts the index should be splitted?
   , mkIndexPartPath:
-    \(partId :: Int) -> "/index/declarations/" <> show partId <> ".js"
+    \(partId :: Int) -> "html/index/declarations/" <> show partId <> ".js"
   , mkIndexPartLoadPath:
-    \(partId :: Int) -> "../index/declarations/" <> show partId <> ".js"
+    \(partId :: Int) -> "./index/declarations/" <> show partId <> ".js"
+  , packageInfoPath: "generated-docs/html/index/packages.json"
+  -- ^ Path to package index.
+  , packageInfoLoadPath: "./index/packages.json"
+  -- ^ Used to load package index to the browser scope.
   , resultsCount: 25
   -- ^ How many results to show by default?
   , penalties: { typeVars: 2
diff --git a/src/Docs/Search/Declarations.purs b/src/Docs/Search/Declarations.purs
index 0090ba5..1535daf 100644
--- a/src/Docs/Search/Declarations.purs
+++ b/src/Docs/Search/Declarations.purs
@@ -1,11 +1,12 @@
 module Docs.Search.Declarations where
 
-import Prelude
-
-import Docs.Search.SearchResult (ResultInfo(..), SearchResult(..))
 import Docs.Search.DocsJson (ChildDeclType(..), ChildDeclaration(..), DeclType(..), Declaration(..), DocsJson(..))
+import Docs.Search.PackageIndex (Scores)
+import Docs.Search.SearchResult (ResultInfo(..), SearchResult(..))
 import Docs.Search.TypeDecoder (Constraint(..), QualifiedName(..), Type(..), Kind, joinForAlls)
 
+import Prelude
+
 import Control.Alt ((<|>))
 import Data.Array ((!!))
 import Data.Array as Array
@@ -19,10 +20,13 @@ import Data.String.CodeUnits (stripPrefix, stripSuffix, toCharArray)
 import Data.String.Common (split) as String
 import Data.String.Common (toLower)
 import Data.String.Pattern (Pattern(..))
+import Data.Map as Map
+
 
 type ModuleName = String
 type PackageName = String
 
+
 newtype Declarations
   = Declarations (Trie Char (List SearchResult))
 
@@ -30,23 +34,29 @@ derive instance newtypeDeclarations :: Newtype Declarations _
 derive newtype instance semigroupDeclarations :: Semigroup Declarations
 derive newtype instance monoidDeclarations :: Monoid Declarations
 
-mkDeclarations :: Array DocsJson -> Declarations
-mkDeclarations = Declarations <<< foldr insertDocsJson mempty
+
+mkDeclarations :: Scores -> Array DocsJson -> Declarations
+mkDeclarations scores = Declarations <<< foldr (insertDocsJson scores) mempty
+
 
 insertDocsJson
-  :: DocsJson
+  :: Scores
+  -> DocsJson
   -> Trie Char (List SearchResult)
   -> Trie Char (List SearchResult)
-insertDocsJson (DocsJson { name, declarations }) trie
-  = foldr (insertDeclaration name) trie declarations
+insertDocsJson scores (DocsJson { name, declarations }) trie
+  = foldr (insertDeclaration scores name) trie declarations
+
 
 insertDeclaration
-  :: ModuleName
+  :: Scores
+  -> ModuleName
   -> Declaration
   -> Trie Char (List SearchResult)
   -> Trie Char (List SearchResult)
-insertDeclaration moduleName entry@(Declaration { title }) trie
-  = foldr insertSearchResult trie (resultsForDeclaration moduleName entry)
+insertDeclaration scores moduleName entry@(Declaration { title }) trie
+  = foldr insertSearchResult trie (resultsForDeclaration scores moduleName entry)
+
 
 insertSearchResult
   :: { path :: String
@@ -64,15 +74,17 @@ insertSearchResult { path, result } trie =
         | otherwise =
             List.singleton result
 
+
 -- | For each declaration, extract its own `SearchResult` and `SearchResult`s
 -- | corresponding to its children (e.g. a class declaration contains class members).
 resultsForDeclaration
-  :: ModuleName
+  :: Scores
+  -> ModuleName
   -> Declaration
   -> List { path :: String
           , result :: SearchResult
           }
-resultsForDeclaration moduleName indexEntry@(Declaration entry) =
+resultsForDeclaration scores moduleName indexEntry@(Declaration entry) =
   let { info, title, sourceSpan, comments, children } = entry
       { name, declLevel } = getLevelAndName info.declType title
       packageName = extractPackageName sourceSpan.name
@@ -85,6 +97,7 @@ resultsForDeclaration moduleName indexEntry@(Declaration entry) =
                                    , moduleName
                                    , sourceSpan: Just sourceSpan
                                    , packageName
+                                   , score: fromMaybe 0 $ Map.lookup packageName scores
                                    , info: info'
                                    }
          in
@@ -94,9 +107,10 @@ resultsForDeclaration moduleName indexEntry@(Declaration entry) =
                }
            ) <>
            ( List.fromFoldable children >>=
-             resultsForChildDeclaration packageName moduleName result
+             resultsForChildDeclaration scores packageName moduleName result
            )
 
+
 mkInfo :: DeclLevel -> Declaration -> Maybe ResultInfo
 mkInfo declLevel (Declaration { info, title }) =
   case info.declType of
@@ -134,16 +148,19 @@ mkInfo declLevel (Declaration { info, title }) =
     DeclExternKind ->
       Just ExternKindResult
 
+
 -- | Level of a declaration, used to determine which URI hash anchor to use in
 -- | links ("v", "t" or "k").
 data DeclLevel = ValueLevel | TypeLevel | KindLevel
 
+
 declLevelToHashAnchor :: DeclLevel -> String
 declLevelToHashAnchor = case _ of
   ValueLevel -> "v"
   TypeLevel  -> "t"
   KindLevel  -> "k"
 
+
 getLevelAndName
   :: DeclType
   -> String
@@ -170,6 +187,7 @@ getLevelAndName DeclAlias       title =
 getLevelAndName DeclExternData  name = { name, declLevel: TypeLevel }
 getLevelAndName DeclExternKind  name = { name, declLevel: KindLevel }
 
+
 -- | Extract package name from `sourceSpan.name`, which contains path to
 -- | the source file.
 extractPackageName :: String -> String
@@ -190,14 +208,16 @@ extractPackageName name =
         Nothing ->
           Just "<local package>"
 
+
 -- | Extract `SearchResults` from a `ChildDeclaration`.
 resultsForChildDeclaration
-  :: PackageName
+  :: Scores
+  -> PackageName
   -> ModuleName
   -> SearchResult
   -> ChildDeclaration
   -> List { path :: String, result :: SearchResult }
-resultsForChildDeclaration packageName moduleName parentResult
+resultsForChildDeclaration scores packageName moduleName parentResult
   child@(ChildDeclaration { title, info, comments, mbSourceSpan })
   | Just resultInfo <- mkChildInfo parentResult child =
         { path: title
@@ -211,11 +231,13 @@ resultsForChildDeclaration packageName moduleName parentResult
                                , moduleName
                                , sourceSpan: mbSourceSpan
                                , packageName
+                               , score: fromMaybe 0 $ Map.lookup packageName scores
                                , info: resultInfo
                                }
         } # List.singleton
   | otherwise = mempty
 
+
 mkChildInfo
   :: SearchResult
   -> ChildDeclaration
@@ -279,5 +301,3 @@ mkChildInfo
          }
 
   | otherwise = Nothing
-
-mkChildInfo _ _ = Nothing
diff --git a/src/Docs/Search/DocsJson.purs b/src/Docs/Search/DocsJson.purs
index 5a9fa74..c605eca 100644
--- a/src/Docs/Search/DocsJson.purs
+++ b/src/Docs/Search/DocsJson.purs
@@ -14,6 +14,7 @@ import Data.Generic.Rep.Show (genericShow)
 import Data.Maybe (Maybe(..))
 import Data.Newtype (class Newtype, unwrap)
 
+
 newtype DocsJson
   = DocsJson { name :: String
              , declarations :: Array Declaration
@@ -32,6 +33,7 @@ instance decodeJsonDocsJson :: DecodeJson DocsJson where
 instance encodeJsonDocsJson :: EncodeJson DocsJson where
   encodeJson = encodeJson <<< unwrap
 
+
 newtype Declaration
   = Declaration { title :: String
                , comments :: Maybe String
@@ -81,6 +83,7 @@ instance decodeJsonDeclaration :: DecodeJson Declaration where
 instance encodeJsonDeclaration :: EncodeJson Declaration where
   encodeJson = encodeJson <<< unwrap
 
+
 newtype ChildDeclaration
   = ChildDeclaration { title :: String
                      , comments :: Maybe String
@@ -117,6 +120,7 @@ instance decodeJsonChildDeclaration :: DecodeJson ChildDeclaration where
 instance encodeJsonChildDeclaration :: EncodeJson ChildDeclaration where
   encodeJson = encodeJson <<< unwrap
 
+
 -- See `src/Language/Purescript/Docs/Types.hs`
 data DeclType
   = DeclValue
@@ -158,6 +162,7 @@ instance decodeJsonDeclType :: DecodeJson DeclType where
           "kind"        -> Right DeclExternKind
           _             -> Left $ "Couldn't decode DeclType: " <> string
 
+
 data ChildDeclType
   = ChildDeclInstance
   | ChildDeclDataConstructor
@@ -186,6 +191,7 @@ instance decodeJsonChildDeclType :: DecodeJson ChildDeclType where
           "typeClassMember" -> Right ChildDeclTypeClassMember
           _                 -> Left $ "Couldn't decode ChildDeclType: " <> tag
 
+
 data DataDeclType
   = NewtypeDataDecl
   | DataDataDecl
diff --git a/src/Docs/Search/Engine.purs b/src/Docs/Search/Engine.purs
index 45ce188..3f0ef3f 100644
--- a/src/Docs/Search/Engine.purs
+++ b/src/Docs/Search/Engine.purs
@@ -1,60 +1,106 @@
--- | A "search engine" that determines if a query is a declaration query or a type query, and
--- | searches for it in the corresponding index.
 module Docs.Search.Engine where
 
-import Prelude
+import Docs.Search.PackageIndex (PackageIndex, PackageResult)
+import Docs.Search.SearchResult (SearchResult)
+import Docs.Search.TypeQuery (TypeQuery(..), parseTypeQuery)
 
-import Docs.Search.TypeQuery (TypeQuery(..), parseTypeQuery, penalty)
-import Docs.Search.SearchResult (SearchResult, typeOfResult)
-import Docs.Search.Index as Index
-import Docs.Search.Index (Index)
-import Docs.Search.TypeIndex as TypeIndex
-import Docs.Search.TypeIndex (TypeIndex)
+import Prelude
 
+import Data.Newtype (unwrap)
 import Data.Array as Array
 import Data.Either (hush)
 import Data.Maybe (Maybe(..))
-import Data.String.Common as String
-import Effect.Aff (Aff)
+import Data.Search.Trie (Trie)
+import Data.String.Common (toLower) as String
+import Data.List (List)
+
+
+type Index = Trie Char (List SearchResult)
+
+
+type Query m index input result =
+  index -> input -> m { index :: index, results :: Array result }
+
+
+type Engine m index typeIndex =
+  { queryIndex
+    :: Query m index String SearchResult
+  , queryTypeIndex
+    :: Query m typeIndex TypeQuery SearchResult
+  , queryPackageIndex
+    :: Query m PackageIndex String PackageResult
+  }
+
+
+type EngineState index typeIndex
+  = { index :: index
+    , typeIndex :: typeIndex
+    , packageIndex :: PackageIndex
+    }
+
+
+mkEngineState
+  :: forall index typeIndex
+  .  index
+  -> typeIndex
+  -> PackageIndex
+  -> EngineState index typeIndex
+mkEngineState index typeIndex packageIndex =
+  { index, typeIndex, packageIndex }
 
-data ResultsType = TypeResults TypeQuery | DeclResults
 
-type State = { index :: Index
-             , typeIndex :: TypeIndex
-             }
+data Result
+  = DeclResult SearchResult
+  | TypeResult SearchResult
+  | PackResult PackageResult
+
+
+sortByPopularity :: Array Result -> Array Result
+sortByPopularity =
+  Array.sortWith
+  \result ->
+    -- Sort by popularity, show packages before
+    -- ordinary definitions.
+    - case result of
+        DeclResult r -> 2 * (unwrap r).score
+        TypeResult r -> 2 * (unwrap r).score
+        PackResult r -> 2 * r.score + 1
+
 
 query
-  :: State
-  -> String
-  -> Aff { searchEngineState :: State
-         , results :: Array SearchResult
-         , resultsType :: ResultsType
-         }
-query { index, typeIndex } input =
+  :: forall m index typeIndex
+  .  Monad m
+  => Engine m index typeIndex
+  -> Query m (EngineState index typeIndex) String Result
+query engine state input =
   case hush (parseTypeQuery input) >>= isValuableTypeQuery of
+
+    -- A declaration/package query
     Nothing -> do
-      response <- Index.query index (String.toLower input)
-      pure { searchEngineState: { index: response.index, typeIndex }
-           , results: response.results
-           , resultsType: DeclResults }
+      let lower = String.toLower input
+
+      response        <- engine.queryIndex        state.index        lower
+      packageResponse <- engine.queryPackageIndex state.packageIndex lower
+
+      pure { results: sortByPopularity $
+             (packageResponse.results <#> PackResult) <>
+             (response.results        <#> DeclResult)
 
+             -- No need to update package index (it never changes).
+           , index: state { index = response.index }
+           }
+
+    -- A type query
     Just typeQuery -> do
-      response <- TypeIndex.query typeIndex typeQuery
-      pure { searchEngineState: { index, typeIndex: response.typeIndex }
-           , results: sortByDistance typeQuery response.results
-           , resultsType: TypeResults typeQuery }
+
+      response <- engine.queryTypeIndex state.typeIndex typeQuery
+
+      pure { results: response.results <#> TypeResult
+           , index: state { typeIndex = response.index }
+           }
+
 
 isValuableTypeQuery :: TypeQuery -> Maybe TypeQuery
 isValuableTypeQuery (QVar _) = Nothing
 isValuableTypeQuery (QConst _) = Nothing
 isValuableTypeQuery other = Just other
-
-sortByDistance :: TypeQuery -> Array SearchResult -> Array SearchResult
-sortByDistance typeQuery results =
-  _.result <$> Array.sortBy comparePenalties resultsWithPenalties
-  where
-    comparePenalties r1 r2 = compare r1.penalty r2.penalty
-    resultsWithPenalties =
-      results <#>
-      \result -> { penalty: typeOfResult result <#> penalty typeQuery
-                 , result }
diff --git a/src/Docs/Search/Extra.purs b/src/Docs/Search/Extra.purs
index d04ec8d..a8625dd 100644
--- a/src/Docs/Search/Extra.purs
+++ b/src/Docs/Search/Extra.purs
@@ -2,8 +2,9 @@ module Docs.Search.Extra where
 
 import Prelude
 
+import Data.Array as Array
 import Data.Foldable (class Foldable, foldMap, foldl)
-import Data.List ((:))
+import Data.List (List, (:))
 import Data.List as List
 import Data.List.NonEmpty (NonEmptyList, cons', uncons)
 import Data.String.CodeUnits as String
@@ -33,9 +34,14 @@ foldr1 f = go List.Nil
         Just { head: head1, tail: tail1 } ->
           go (head : acc) (cons' head1 tail1)
 
-
 -- | Try to guess repository main page on github from git URL.
 homePageFromRepository :: String -> String
 homePageFromRepository repo =
   fromMaybe repo $ String.stripSuffix (wrap ".git") $
   fromMaybe repo $ String.stripPrefix (wrap "git:") repo <#> ("https:" <> _)
+
+stringToList :: String -> List Char
+stringToList = List.fromFoldable <<< String.toCharArray
+
+listToString :: List Char -> String
+listToString = String.fromCharArray <<< Array.fromFoldable
diff --git a/src/Docs/Search/IndexBuilder.purs b/src/Docs/Search/IndexBuilder.purs
index 4d1bcbc..5170aed 100644
--- a/src/Docs/Search/IndexBuilder.purs
+++ b/src/Docs/Search/IndexBuilder.purs
@@ -1,33 +1,33 @@
 module Docs.Search.IndexBuilder where
 
-import Prelude
-
 import Docs.Search.Config (config)
 import Docs.Search.Declarations (Declarations(..), mkDeclarations)
 import Docs.Search.DocsJson (DocsJson)
 import Docs.Search.Extra ((>#>))
-import Docs.Search.Index (getPartId, insertResults)
-import Docs.Search.SearchResult (SearchResult(..))
+import Docs.Search.BrowserEngine (getPartId)
+import Docs.Search.PackageIndex (PackageInfo, mkPackageInfo, mkScores)
+import Docs.Search.SearchResult (SearchResult)
 import Docs.Search.TypeIndex (TypeIndex, mkTypeIndex)
 
+import Prelude
+
 import Data.Argonaut.Core (stringify)
 import Data.Argonaut.Decode (decodeJson)
 import Data.Argonaut.Encode (encodeJson)
 import Data.Argonaut.Parser (jsonParser)
 import Data.Array as Array
 import Data.Either (Either(..), either)
-import Data.Foldable (sum, foldr)
+import Data.Foldable (sum)
 import Data.List (List)
 import Data.List as List
 import Data.Map (Map)
 import Data.Map as Map
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Newtype (wrap, unwrap)
-import Data.Profunctor.Strong (second)
+import Data.Newtype (unwrap)
 import Data.Search.Trie as Trie
 import Data.Set as Set
 import Data.String.CodePoints (contains) as String
-import Data.String.CodeUnits (singleton, stripPrefix) as String
+import Data.String.CodeUnits (singleton) as String
 import Data.String.Common (replace) as String
 import Data.String.Pattern (Pattern(..), Replacement(..))
 import Data.Traversable (for, for_)
@@ -53,26 +53,6 @@ run :: Config -> Effect Unit
 run = launchAff_ <<< run'
 
 
-insertPackages
-  :: Array PackageMeta
-  -> Declarations
-  -> Declarations
-insertPackages packageMetas (Declarations decls) =
-  Declarations $
-  foldr (insertResults <<< second pure) decls $
-  map resultFromPackageMeta packageMetas
-
-
-resultFromPackageMeta :: PackageMeta -> Tuple String SearchResult
-resultFromPackageMeta (PackageMeta { name, description, repository }) =
-  Tuple shortName $ PackageResult { name: shortName
-                                  , description
-                                  , repository: fromMaybe "" (repository <#> (_.url))
-                                  }
-
-  where
-    shortName = fromMaybe name $ String.stripPrefix (wrap "purescript-") name
-
 run' :: Config -> Aff Unit
 run' cfg = do
 
@@ -92,20 +72,24 @@ run' cfg = do
       show (Array.length packageMetas) <>
       " packages..."
 
-  let index = insertPackages packageMetas $ mkDeclarations docsJsons
-      typeIndex = mkTypeIndex docsJsons
+  let scores      = mkScores packageMetas
+      index       = mkDeclarations scores docsJsons
+      typeIndex   = mkTypeIndex scores docsJsons
+      packageInfo = mkPackageInfo packageMetas
 
   createDirectories cfg
 
   void $ sequential do
     ignore <$> parallel (writeIndex cfg index)
            <*> parallel (writeTypeIndex cfg typeIndex)
+           <*> parallel (writePackageInfo packageInfo)
            <*> parallel (patchDocs cfg)
            <*> parallel (copyAppFile cfg)
 
   let countOfDefinitions = Trie.size $ unwrap index
       countOfTypeDefinitions =
         sum $ fromMaybe 0 <$> map Array.length <$> Map.values (unwrap typeIndex)
+      countOfPackages = Array.length packageMetas
 
   liftEffect do
     log $
@@ -113,9 +97,11 @@ run' cfg = do
       show countOfDefinitions <>
       " definitions and " <>
       show countOfTypeDefinitions <>
-      " type definitions to the search index."
+      " type definitions from " <>
+      show countOfPackages <>
+      " packages to the search index."
 
-  where ignore _ _ _ _ = unit
+  where ignore _ _ _ _ _ = unit
 
 
 -- | Exit early if something is missing.
@@ -211,7 +197,7 @@ decodeBowerJsons { bowerFiles } = do
 writeTypeIndex :: Config -> TypeIndex -> Aff Unit
 writeTypeIndex { generatedDocs } typeIndex =
   for_ entries \(Tuple typeShape results) -> do
-    writeTextFile UTF8 (generatedDocs <> "/index/types/" <> typeShape <> ".js")
+    writeTextFile UTF8 (config.typeIndexDirectory <> "/" <> typeShape <> ".js")
       (mkHeader typeShape <> stringify (encodeJson results))
   where
     mkHeader typeShape =
@@ -221,6 +207,15 @@ writeTypeIndex { generatedDocs } typeIndex =
     entries = Map.toUnfoldableUnordered (unwrap typeIndex)
 
 
+writePackageInfo :: PackageInfo -> Aff Unit
+writePackageInfo packageInfo = do
+
+  writeTextFile UTF8 config.packageInfoPath $
+    header <> stringify (encodeJson packageInfo)
+
+  where
+    header = "window.DocsSearchPackageIndex = "
+
 -- | Get a mapping from index parts to index contents.
 getIndex :: Declarations -> Map Int (Array (Tuple String (Array SearchResult)))
 getIndex (Declarations trie) =
@@ -272,7 +267,7 @@ patchHTML html =
   let
     pattern = Pattern "</body>"
     patch = "<!-- Docs search index. -->" <>
-            "<script type=\"text/javascript\" src=\"../docs-search-app.js\"></script>" <>
+            "<script type=\"text/javascript\" src=\"./docs-search-app.js\"></script>" <>
             "<script type=\"text/javascript\">" <>
             "window.DocsSearchTypeIndex = {};" <>
             "window.DocsSearchIndex = {};" <>
@@ -306,13 +301,17 @@ patchDocs cfg = do
 -- | in case the docs were not generated.
 createDirectories :: Config -> Aff Unit
 createDirectories { generatedDocs } = do
-  let indexDir         = generatedDocs <> "/index"
-      declIndexDir     = generatedDocs <> "/index/declarations"
-      typeIndexDir     = generatedDocs <> "/index/types"
+  let htmlDocs         = generatedDocs <> "/html"
+      indexDir         = generatedDocs <> "/html/index"
+      declIndexDir     = generatedDocs <> "/html/index/declarations"
+      typeIndexDir     = generatedDocs <> "/html/index/types"
 
   whenM (not <$> directoryExists generatedDocs) $ liftEffect do
     logAndExit "Generate the documentation first!"
 
+  whenM (not <$> directoryExists htmlDocs) $ liftEffect do
+    logAndExit "Generate the documentation first!"
+
   whenM (not <$> directoryExists indexDir) do
     mkdir indexDir
 
@@ -335,7 +334,7 @@ copyAppFile { generatedDocs } = do
         "Client-side app was not found at " <> appFile <> ".\n" <>
         "Check your installation."
   buffer <- readFile appFile
-  writeFile (generatedDocs <> "/docs-search-app.js") buffer
+  writeFile (generatedDocs <> "/html/docs-search-app.js") buffer
 
 
 directoryExists :: String -> Aff Boolean
diff --git a/src/Docs/Search/Interactive.purs b/src/Docs/Search/Interactive.purs
index b6ba764..a4ad5da 100644
--- a/src/Docs/Search/Interactive.purs
+++ b/src/Docs/Search/Interactive.purs
@@ -1,42 +1,43 @@
 -- | Definitions for the "search REPL".
 module Docs.Search.Interactive where
 
-import Prelude
-
 import Docs.Search.Declarations (Declarations, mkDeclarations)
 import Docs.Search.DocsJson (DataDeclType(..))
-import Docs.Search.Engine (isValuableTypeQuery)
-import Docs.Search.Engine as SearchEngine
-import Docs.Search.Extra (homePageFromRepository)
+import Docs.Search.Engine (mkEngineState, Result(..))
+import Docs.Search.Engine as Engine
+import Docs.Search.Extra (listToString, stringToList, (>#>))
 import Docs.Search.IndexBuilder as IndexBuilder
+import Docs.Search.NodeEngine (nodeEngine)
+import Docs.Search.PackageIndex (PackageResult, mkPackageIndex, mkPackageInfo, mkScores)
 import Docs.Search.SearchResult (ResultInfo(..), SearchResult(..))
 import Docs.Search.Terminal (bold, cyan, green, yellow)
 import Docs.Search.TypeDecoder (Constraint, FunDeps, Kind, QualifiedName, Type, TypeArgument)
 import Docs.Search.TypeIndex (resultsWithTypes)
 import Docs.Search.TypePrinter (keyword, showConstraint, showFunDeps, showKind, showType, showTypeArgument, space, syntax)
-import Docs.Search.TypeQuery (parseTypeQuery)
 
+import Prelude
+
+import Data.Identity (Identity(..))
 import Data.Array as Array
-import Data.Either (hush)
-import Data.List as List
-import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Newtype (unwrap, wrap)
+import Data.Maybe (fromMaybe)
 import Data.Search.Trie as Trie
 import Data.String (length) as String
-import Data.String.CodeUnits (fromCharArray, toCharArray) as String
-import Data.String.Common (split, toLower, trim) as String
+import Data.String.Common (split, trim) as String
 import Data.Tuple (fst)
 import Effect (Effect)
 import Effect.Aff (launchAff_)
 import Effect.Class (liftEffect)
 import Effect.Console (log)
 import Node.ReadLine (createConsoleInterface, question)
+import Data.Newtype (un, unwrap, wrap)
+
 
 type Config =
   { docsFiles :: Array String
   , bowerFiles :: Array String
   }
 
+
 run :: Config -> Effect Unit
 run cfg = launchAff_ $ do
 
@@ -46,14 +47,15 @@ run cfg = launchAff_ $ do
   docsJsons    <- IndexBuilder.decodeDocsJsons cfg
   packageMetas <- IndexBuilder.decodeBowerJsons cfg
 
-  let index =
-        IndexBuilder.insertPackages packageMetas $
-        mkDeclarations docsJsons
-      typeIndex = docsJsons >>= resultsWithTypes
+  let scores       = mkScores packageMetas
+      index        = mkDeclarations scores docsJsons
+      typeIndex    = docsJsons >>= resultsWithTypes scores
+      packageIndex = mkPackageIndex $ mkPackageInfo packageMetas
+      engineState  = mkEngineState (unwrap index) typeIndex packageIndex
 
-  let countOfDefinitions = Trie.size $ unwrap index
-      countOfTypeDefinitions =
-        Array.length typeIndex
+  let countOfDefinitions     = Trie.size $ unwrap index
+      countOfTypeDefinitions = Array.length typeIndex
+      countOfPackages        = Array.length packageMetas
 
   liftEffect do
     log $
@@ -61,7 +63,9 @@ run cfg = launchAff_ $ do
       show countOfDefinitions <>
       " definitions and " <>
       show countOfTypeDefinitions <>
-      " type definitions."
+      " type definitions from " <>
+      show countOfPackages <> " packages."
+
 
   liftEffect do
     let
@@ -69,19 +73,9 @@ run cfg = launchAff_ $ do
         question "> " (handler interface) interface
 
       inputHandler interface input = do
+
         let results =
-              case hush (parseTypeQuery input) >>= isValuableTypeQuery of
-                Nothing ->
-                  Array.fromFoldable $
-                  List.concat $
-                  Trie.queryValues (List.fromFoldable $
-                                    String.toCharArray $
-                                    String.toLower $
-                                    input) (unwrap index)
-
-                Just typeQuery ->
-                  Array.take 100 $
-                  SearchEngine.sortByDistance typeQuery typeIndex
+              Engine.query nodeEngine engineState input <#> (_.results) # un Identity
 
         let total = Array.length results
 
@@ -96,29 +90,36 @@ run cfg = launchAff_ $ do
             "Your search for " <> bold input <> " did not yield any results."
         call inputHandler interface
 
-    interface <- do
-      interface <- createConsoleInterface (mkCompleter index)
-      pure interface
+    interface <- createConsoleInterface (mkCompleter index)
 
     call inputHandler interface
 
+
 mkCompleter
   :: Declarations
   -> String
   -> Effect { completions :: Array String
             , matched :: String }
 mkCompleter index input = do
-  let path = List.fromFoldable $ String.toCharArray input
+  let path = stringToList input
   let paths =
         Array.fromFoldable $
-        (String.fromCharArray <<< Array.fromFoldable) <$>
+        listToString <$>
         (fst <$> Trie.query path (unwrap index))
 
   pure { completions: paths
        , matched: input }
 
-showResult :: SearchResult -> String
-showResult (SearchResult result@{ name, comments, moduleName, packageName }) =
+
+showResult :: Result -> String
+showResult = case _ of
+  DeclResult sr -> showSearchResult sr
+  TypeResult sr -> showSearchResult sr
+  PackResult pr -> showPackageResult pr
+
+
+showSearchResult :: SearchResult -> String
+showSearchResult (SearchResult result@{ name, comments, moduleName, packageName }) =
   showSignature result <> "\n" <>
 
   (fromMaybe "\n" $
@@ -126,12 +127,13 @@ showResult (SearchResult result@{ name, comments, moduleName, packageName }) =
    "\n" <> leftShift 3 (String.trim comment) <> "\n\n") <>
 
   bold (cyan (rightPad 40 packageName)) <> space <> bold (green moduleName)
-showResult (PackageResult { name, description, repository }) =
-  cyan "package" <> " " <> yellow name <> "\n" <>
-  (fromMaybe "\n" $
-   description <#> \text ->
-   "\n" <> leftShift 3 text <> "\n\n") <>
-  leftShift 3 (homePageFromRepository repository)
+
+
+showPackageResult :: PackageResult -> String
+showPackageResult { name, description } =
+  bold (cyan "package") <> " " <> bold (yellow name) <>
+
+  (description >#> \text -> "\n\n" <> leftShift 3 text <> "\n")
 
 
 showSignature ::
@@ -168,6 +170,7 @@ showSignature result@{ name, info } =
 
     _ -> yellow name
 
+
 showTypeClassSignature
   :: forall rest
   .  { fundeps :: FunDeps
@@ -201,6 +204,7 @@ showTypeClassSignature { fundeps, arguments, superclasses } { name, moduleName }
     showFunDeps fundeps
   )
 
+
 showTypeClassMemberSignature
   :: forall rest
   .  { type :: Type
@@ -214,6 +218,7 @@ showTypeClassMemberSignature { type: ty, typeClass, typeClassArguments } result
   syntax " :: " <>
   showType ty
 
+
 showDataSignature
   :: forall rest
   .  { typeArguments :: Array TypeArgument
@@ -233,6 +238,7 @@ showDataSignature { typeArguments, dataDeclType } { name } =
       typeArguments <#> showTypeArgument
   )
 
+
 showTypeSynonymSignature
   :: forall rest
   .  { type :: Type
@@ -253,6 +259,7 @@ showTypeSynonymSignature { type: ty, arguments } { name } =
   space <>
   showType ty
 
+
 showExternDataSignature
   :: forall rest
   .  { kind :: Kind }
@@ -266,6 +273,7 @@ showExternDataSignature { kind } { name } =
   syntax " :: " <>
   showKind kind
 
+
 leftShift :: Int -> String -> String
 leftShift shift str =
   Array.intercalate "\n" $
@@ -273,10 +281,13 @@ leftShift shift str =
   String.trim <$>
   String.split (wrap "\n") str
 
+
 leftPad :: Int -> String -> String
 leftPad w str = Array.fold (Array.replicate w " ") <> str
 
+
 rightPad :: Int -> String -> String
 rightPad w str = str <> Array.fold (Array.replicate (w - String.length str) " ")
 
+
 foreign import consoleClear :: Effect Unit
diff --git a/src/Docs/Search/NodeEngine.purs b/src/Docs/Search/NodeEngine.purs
new file mode 100644
index 0000000..f920702
--- /dev/null
+++ b/src/Docs/Search/NodeEngine.purs
@@ -0,0 +1,55 @@
+-- | A search engine that can be used in nodejs invironment.
+module Docs.Search.NodeEngine where
+
+import Docs.Search.Extra (stringToList)
+import Docs.Search.PackageIndex as PackageIndex
+import Docs.Search.Engine (Engine, Query, Index)
+import Docs.Search.SearchResult (SearchResult, typeOfResult)
+import Docs.Search.TypeQuery (TypeQuery, penalty)
+
+import Prelude
+
+import Data.Array as Array
+import Data.Identity (Identity)
+import Data.List as List
+import Data.Search.Trie as Trie
+import Data.String.Common (toLower)
+
+
+type NodeEngine = Engine Identity Index (Array SearchResult)
+
+
+nodeEngine :: NodeEngine
+nodeEngine =
+  { queryIndex
+  , queryTypeIndex
+  , queryPackageIndex: PackageIndex.queryPackageIndex
+  }
+
+
+queryIndex :: Query Identity Index String SearchResult
+queryIndex index input =
+  pure { index, results:
+                Array.fromFoldable $
+                List.concat $
+                Trie.queryValues
+                (stringToList $ toLower input)
+                index
+       }
+
+
+queryTypeIndex
+  :: Query Identity (Array SearchResult) TypeQuery SearchResult
+queryTypeIndex index typeQuery =
+  pure { index, results:
+                Array.take 100 $
+                sortByDistance typeQuery index
+       }
+
+
+sortByDistance
+  :: TypeQuery
+  -> Array SearchResult
+  -> Array SearchResult
+sortByDistance typeQuery =
+  Array.sortWith (map (penalty typeQuery) <<< typeOfResult)
diff --git a/src/Docs/Search/PackageIndex.js b/src/Docs/Search/PackageIndex.js
new file mode 100644
index 0000000..29bf0ed
--- /dev/null
+++ b/src/Docs/Search/PackageIndex.js
@@ -0,0 +1,24 @@
+/* global exports */
+
+exports.load = function (url) {
+  return function () {
+    return new Promise(function (resolve, reject) {
+      if (typeof window.DocsSearchPackageIndex === 'undefined') {
+        var script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = url;
+        script.addEventListener('load', function () {
+          if (typeof window.DocsSearchPackageIndex === 'undefined') {
+            reject(new Error("Couldn't load index for type shape " + shape));
+          } else {
+            resolve(window.DocsSearchPackageIndex);
+          }
+        });
+        script.addEventListener('error', reject);
+        document.body.appendChild(script);
+      } else {
+        resolve(window.DocsSearchPackageIndex);
+      }
+    });
+  };
+};
diff --git a/src/Docs/Search/PackageIndex.purs b/src/Docs/Search/PackageIndex.purs
new file mode 100644
index 0000000..1db1fbc
--- /dev/null
+++ b/src/Docs/Search/PackageIndex.purs
@@ -0,0 +1,128 @@
+module Docs.Search.PackageIndex where
+
+import Docs.Search.Config (config)
+import Docs.Search.Extra (stringToList)
+
+import Prelude
+
+import Data.Either (hush)
+import Data.Maybe (Maybe, fromMaybe)
+import Data.Newtype (unwrap, wrap)
+import Effect (Effect)
+import Effect.Aff (Aff)
+import Web.Bower.PackageMeta (Dependencies, PackageMeta(..))
+import Control.Promise (Promise, toAffE)
+import Data.Argonaut.Core (Json)
+import Data.Argonaut.Decode (decodeJson)
+import Data.Array as Array
+import Data.Map (Map)
+import Data.Map as Map
+import Data.Search.Trie (Trie)
+import Data.Search.Trie as Trie
+import Data.String.CodeUnits as String
+
+
+type PackageResult
+  = { name :: String
+    , description :: Maybe String
+    , score :: Int
+    , dependencies :: Array String
+    , repository :: Maybe String
+    }
+
+type Scores = Map String Int
+
+type PackageIndex = Trie Char PackageResult
+
+type PackageInfo = Array PackageResult
+
+
+-- | Construct a mapping from package names to their scores, based on number
+-- of reverse dependencies.
+mkScores :: Array PackageMeta -> Scores
+mkScores =
+  Array.foldr
+  (\pm ->
+    updateScoresFor (unwrap pm).dependencies >>>
+    updateScoresFor (unwrap pm).devDependencies
+  )
+  mempty
+
+  where
+    updateScoresFor :: Dependencies -> Scores -> Scores
+    updateScoresFor deps scores =
+      Array.foldr
+      (\dep -> Map.insertWith add dep 1)
+      scores
+      (deps # unwrap >>> map (_.packageName))
+
+
+mkPackageInfo :: Array PackageMeta -> PackageInfo
+mkPackageInfo pms =
+  Array.fromFoldable $
+  Map.values $
+  Array.foldr insert mempty pms
+
+  where
+    packageScores = mkScores pms
+
+
+    insert
+      :: PackageMeta
+      -> Map String PackageResult
+      -> Map String PackageResult
+    insert
+      (PackageMeta { name
+                   , description
+                   , dependencies
+                   , devDependencies
+                   , repository }) =
+
+          Map.insert
+          name
+          { name
+          , description: description
+          , score: fromMaybe 0 $ Map.lookup name packageScores
+          , dependencies: unwrap dependencies <#> (_.packageName)
+          , repository: repository <#> (_.url)
+          }
+
+
+loadPackageIndex :: Aff PackageIndex
+loadPackageIndex = do
+  json <- toAffE (load config.packageInfoLoadPath)
+  let packageInfo = fromMaybe mempty $ hush $ decodeJson json
+  pure $ mkPackageIndex packageInfo
+
+
+mkPackageIndex :: PackageInfo -> PackageIndex
+mkPackageIndex =
+
+  Array.foldr
+  (\package -> Trie.insert (shortNamePath package.name) package)
+  mempty
+
+  where
+    shortNamePath name =
+      stringToList $
+      fromMaybe name $
+      String.stripPrefix (wrap "purescript-") name
+
+
+queryPackageIndex
+  :: forall m
+  .  Monad m
+  => PackageIndex
+  -> String
+  -> m { index :: PackageIndex
+       , results :: Array PackageResult
+       }
+queryPackageIndex index q =
+  pure { index
+       , results: Array.fromFoldable $ Trie.queryValues (stringToList q) index
+       }
+
+
+foreign import load
+  :: String
+  -> Effect (Promise Json)
diff --git a/src/Docs/Search/SearchResult.purs b/src/Docs/Search/SearchResult.purs
index 5decc47..6739184 100644
--- a/src/Docs/Search/SearchResult.purs
+++ b/src/Docs/Search/SearchResult.purs
@@ -1,15 +1,17 @@
 module Docs.Search.SearchResult where
 
 import Docs.Search.DocsJson (DataDeclType)
-import Docs.Search.Extra (homePageFromRepository)
 import Docs.Search.TypeDecoder (Constraint, FunDeps, Kind, QualifiedName, Type, TypeArgument)
 
+import Prelude
+
 import Data.Argonaut.Decode (class DecodeJson)
 import Data.Argonaut.Decode.Generic.Rep (genericDecodeJson)
 import Data.Argonaut.Encode (class EncodeJson)
 import Data.Argonaut.Encode.Generic.Rep (genericEncodeJson)
 import Data.Generic.Rep (class Generic)
 import Data.Maybe (Maybe(..))
+import Data.Newtype (class Newtype, un)
 
 
 -- | Metadata that makes sense only for certain types of search results.
@@ -39,6 +41,7 @@ instance encodeJsonResultInfo :: EncodeJson ResultInfo where
 instance decodeJsonResultInfo :: DecodeJson ResultInfo where
   decodeJson = genericDecodeJson
 
+
 -- | Extract the type field.
 typeOf :: ResultInfo -> Maybe Type
 typeOf (TypeSynonymResult { type: res }) =
@@ -49,27 +52,25 @@ typeOf (ValueResult { type: res }) =
   Just res
 typeOf _ = Nothing
 
+
 -- | Common metadata for all types of search results.
-data SearchResult
+newtype SearchResult
   = SearchResult
     { name :: String
     , comments :: Maybe String
     , hashAnchor :: String
     , moduleName :: String
     , packageName :: String
+    , score :: Int
     , sourceSpan :: Maybe { start :: Array Int
                           , end :: Array Int
                           , name :: String
                           }
     , info :: ResultInfo
     }
-  | PackageResult
-    { name :: String
-    , description :: Maybe String
-    , repository :: String
-    }
 
 derive instance genericSearchResult :: Generic SearchResult _
+derive instance newtypeSearchResult :: Newtype SearchResult _
 
 instance encodeJsonSearchResult :: EncodeJson SearchResult where
   encodeJson = genericEncodeJson
@@ -77,6 +78,6 @@ instance encodeJsonSearchResult :: EncodeJson SearchResult where
 instance decodeJsonSearchResult :: DecodeJson SearchResult where
   decodeJson = genericDecodeJson
 
+
 typeOfResult :: SearchResult -> Maybe Type
-typeOfResult (SearchResult { info }) = typeOf info
-typeOfResult _ = Nothing
+typeOfResult = un SearchResult >>> (_.info) >>> typeOf
diff --git a/src/Docs/Search/TypeIndex.purs b/src/Docs/Search/TypeIndex.purs
index d007588..4aede14 100644
--- a/src/Docs/Search/TypeIndex.purs
+++ b/src/Docs/Search/TypeIndex.purs
@@ -1,15 +1,17 @@
+-- | Partial type index, can be loaded on demand in the browser.
 module Docs.Search.TypeIndex where
 
-import Prelude
-
 import Docs.Search.Config (config)
 import Docs.Search.Declarations (resultsForDeclaration)
 import Docs.Search.DocsJson (DocsJson(..))
+import Docs.Search.PackageIndex (Scores)
 import Docs.Search.SearchResult (ResultInfo(..), SearchResult(..))
 import Docs.Search.TypeDecoder (Type)
 import Docs.Search.TypeQuery (TypeQuery)
 import Docs.Search.TypeShape (shapeOfType, shapeOfTypeQuery, stringifyShape)
 
+import Prelude
+
 import Control.Promise (Promise, toAffE)
 import Data.Argonaut.Core (Json)
 import Data.Argonaut.Decode (decodeJson)
@@ -22,14 +24,16 @@ import Data.Newtype (class Newtype, unwrap, wrap)
 import Effect (Effect)
 import Effect.Aff (Aff, try)
 
+
 newtype TypeIndex = TypeIndex (Map String (Maybe (Array SearchResult)))
 
 derive newtype instance semigroupTypeIndex :: Semigroup TypeIndex
 derive newtype instance monoidTypeIndex :: Monoid TypeIndex
 derive instance newtypeTypeIndex :: Newtype TypeIndex _
 
-mkTypeIndex :: Array DocsJson -> TypeIndex
-mkTypeIndex docsJsons =
+
+mkTypeIndex :: Scores -> Array DocsJson -> TypeIndex
+mkTypeIndex scores docsJsons =
   TypeIndex $ map Just $ Array.foldr insert mempty docsJsons
   where
     insert :: DocsJson -> Map String (Array SearchResult) -> Map String (Array SearchResult)
@@ -39,14 +43,17 @@ mkTypeIndex docsJsons =
                       Just ty ->
                         Map.insertWith append (stringifyShape $ shapeOfType ty) (pure result)
                       Nothing -> identity
-                  ) mp (allResults docsJson)
+                  ) mp (allResults scores docsJson)
 
-allResults :: DocsJson -> Array SearchResult
-allResults (DocsJson { name, declarations }) =
-  declarations >>= (resultsForDeclaration name >>> map (_.result) >>> Array.fromFoldable)
 
-resultsWithTypes :: DocsJson -> Array SearchResult
-resultsWithTypes docsJson = Array.filter (getType >>> isJust) $ allResults docsJson
+allResults :: Scores -> DocsJson -> Array SearchResult
+allResults scores (DocsJson { name, declarations }) =
+  declarations >>= (resultsForDeclaration scores name >>> map (_.result) >>> Array.fromFoldable)
+
+
+resultsWithTypes :: Scores -> DocsJson -> Array SearchResult
+resultsWithTypes scores = Array.filter (getType >>> isJust) <<< allResults scores
+
 
 getType :: SearchResult -> Maybe Type
 getType (SearchResult { info }) =
@@ -61,23 +68,23 @@ getType (SearchResult { info }) =
       Just dict.type
 
     _ -> Nothing
-getType _ = Nothing
+
 
 lookup
   :: String
   -> TypeIndex
-  -> Aff { typeIndex :: TypeIndex, results :: Array SearchResult }
-lookup key typeIndex@(TypeIndex map) =
+  -> Aff { index :: TypeIndex, results :: Array SearchResult }
+lookup key index@(TypeIndex map) =
   case Map.lookup key map of
-    Just results -> pure { typeIndex, results: Array.fold results }
+    Just results -> pure { index, results: Array.fold results }
     Nothing -> do
       eiJson <- try (toAffE (lookup_ key $ config.mkShapeScriptPath key))
       pure $ fromMaybe'
-        (\_ ->  { typeIndex: insert key Nothing typeIndex, results: [] })
+        (\_ ->  { index: insert key Nothing index, results: [] })
         do
           json <- hush eiJson
           results <- hush (decodeJson json)
-          pure { typeIndex: insert key (Just results) typeIndex, results }
+          pure { index: insert key (Just results) index, results }
 
   where
     insert
@@ -87,14 +94,16 @@ lookup key typeIndex@(TypeIndex map) =
       -> TypeIndex
     insert k v = unwrap >>> Map.insert k v >>> wrap
 
+
 query
   :: TypeIndex
   -> TypeQuery
-  -> Aff { typeIndex :: TypeIndex, results :: Array SearchResult }
+  -> Aff { index :: TypeIndex, results :: Array SearchResult }
 query typeIndex typeQuery = do
   res <- lookup (stringifyShape $ shapeOfTypeQuery typeQuery) typeIndex
   pure $ res { results = res.results }
 
+
 foreign import lookup_
   :: String
   -> String
diff --git a/src/Docs/Search/TypePrinter.purs b/src/Docs/Search/TypePrinter.purs
index bc82551..346a646 100644
--- a/src/Docs/Search/TypePrinter.purs
+++ b/src/Docs/Search/TypePrinter.purs
@@ -2,13 +2,15 @@ module Docs.Search.TypePrinter where
 
 import Prelude
 
+import Docs.Search.Extra ((>#>))
 import Docs.Search.Terminal (cyan)
 import Docs.Search.TypeDecoder (Constraint(..), FunDep(..), FunDeps(..), Kind(..), QualifiedName(..), Type(..), TypeArgument(..), joinForAlls, joinRows)
 
-import Data.Maybe (Maybe(..))
+import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Array as Array
 import Data.List as List
 
+
 -- | A pretty-printer for types, for TTY with colors.
 showType :: Type -> String
 showType = case _ of
@@ -20,7 +22,9 @@ showType = case _ of
 
   TypeApp (TypeApp (TypeConstructor
                     (QualifiedName { moduleName: [ "Prim" ]
-                                   , name: "Function" })) t1) t2 ->
+                                   , name: "Function" }))
+                   t1)
+          t2 ->
     showType t1 <> syntax " -> " <> showType t2
 
   TypeApp (TypeConstructor (QualifiedName { moduleName: [ "Prim" ]
@@ -54,6 +58,7 @@ showType = case _ of
     showType ty <>
     ")"
 
+
 showTypeArgument :: TypeArgument -> String
 showTypeArgument (TypeArgument { name, mbKind }) =
   case mbKind of
@@ -66,6 +71,7 @@ showTypeArgument (TypeArgument { name, mbKind }) =
       showKind kind <>
       ")"
 
+
 showFunDeps :: FunDeps -> String
 showFunDeps (FunDeps []) = ""
 showFunDeps (FunDeps deps) =
@@ -78,12 +84,14 @@ showFunDeps (FunDeps deps) =
       syntax " -> " <>
       Array.intercalate space rhs
 
+
 showQualifiedName
   :: QualifiedName
   -> String
 showQualifiedName (QualifiedName { name })
   = name
 
+
 showRow
   :: Boolean
   -> Type
@@ -92,7 +100,9 @@ showRow asRow =
   joinRows >>> \ { rows, ty } ->
   if List.null rows
   then
-    if asRow then "()" else "{}"
+    if asRow
+    then "()"
+    else fromMaybe "{}" $ ty <#> \ty' -> "Record " <> showType ty'
   else
     opening <>
     ( Array.intercalate ", " $ Array.fromFoldable $ rows <#>
@@ -100,14 +110,15 @@ showRow asRow =
       entry.row <> syntax " :: " <> showType entry.ty
     ) <>
 
-    case ty of
-      Just ty' -> " | " <> showType ty' <> closing
-      Nothing  -> closing
+    (ty >#> \ty' -> " | " <> showType ty') <>
+
+    closing
 
     where
       opening = if asRow then "(" else "{ "
       closing = if asRow then ")" else " }"
 
+
 showForAll
   :: Type
   -> String
@@ -132,6 +143,7 @@ showForAll ty =
   where
     foralls = joinForAlls ty
 
+
 showKind
   :: Kind
   -> String
@@ -140,6 +152,7 @@ showKind = case _ of
   FunKind k1 k2   -> showKind k1 <> syntax " -> " <> showKind k2
   NamedKind qname -> showQualifiedName qname
 
+
 showConstraint
   :: Constraint
   -> String
@@ -147,6 +160,7 @@ showConstraint (Constraint { constraintClass, constraintArgs }) =
   showQualifiedName constraintClass <> space <>
   Array.intercalate space (constraintArgs <#> showType)
 
+
 syntax :: String -> String
 syntax = cyan
 
diff --git a/src/Docs/Search/TypeQuery.purs b/src/Docs/Search/TypeQuery.purs
index 9cd9ffe..5b68946 100644
--- a/src/Docs/Search/TypeQuery.purs
+++ b/src/Docs/Search/TypeQuery.purs
@@ -10,12 +10,12 @@ module Docs.Search.TypeQuery
        )
 where
 
-import Prelude
-
 import Docs.Search.Config (config)
 import Docs.Search.Extra (foldl1, foldr1)
 import Docs.Search.TypeDecoder (QualifiedName(..), Type(..), joinConstraints, joinRows)
 
+import Prelude
+
 import Control.Alt ((<|>))
 import Data.Array as Array
 import Data.Either (Either)
@@ -37,6 +37,7 @@ import Text.Parsing.StringParser (ParseError, Parser, runParser, try)
 import Text.Parsing.StringParser.CodePoints (alphaNum, anyLetter, char, eof, lowerCaseChar, skipSpaces, string, upperCaseChar)
 import Text.Parsing.StringParser.Combinators (fix, sepBy, sepBy1, sepEndBy, sepEndBy1)
 
+
 -- | We need type queries because we don't have a full-featured type parser
 -- | available.
 data TypeQuery
@@ -54,9 +55,11 @@ derive instance genericTypeQuery :: Generic TypeQuery _
 instance showTypeQuery :: Show TypeQuery where
   show x = genericShow x
 
+
 parseTypeQuery :: String -> Either ParseError TypeQuery
 parseTypeQuery = String.trim >>> runParser (typeQueryParser <* eof)
 
+
 typeQueryParser :: Parser TypeQuery
 typeQueryParser = fix \typeQuery ->
   let rowFields =
@@ -99,6 +102,7 @@ typeQueryParser = fix \typeQuery ->
   in
     try constrained <|> funs
 
+
 any :: Parser TypeQuery
 any = do
   QVar <$> lowerCaseIdent
@@ -166,6 +170,7 @@ getFreeVariables query = go Set.empty Set.empty (List.singleton $ Next query)
     go bound free (Next (QRow lst) : rest) =
       go bound free ((lst <#> snd >>> Next) <> rest)
 
+
 data Substitution
   = Instantiate String Type
   | Match String String
@@ -187,6 +192,7 @@ derive instance genericSubstitution :: Generic Substitution _
 instance showSubstitution :: Show Substitution where
   show x = genericShow x
 
+
 -- | A mock-up of unification algorithm, that does not unify anything, actually.
 -- | We use it to estimate how far a type is from a type query, by looking into
 -- | the resulting list.
@@ -289,6 +295,7 @@ unify query type_ = go Nil (List.singleton { q: query, t: type_ })
     go acc ({ q, t: REmpty } : rest) =
       go (QueryMismatch q : acc) rest
 
+
 -- | Sum various penalties.
 penalty :: TypeQuery -> Type -> Int
 penalty typeQuery ty =
@@ -297,6 +304,7 @@ penalty typeQuery ty =
   namesPenalty substs +
   mismatchPenalty substs
 
+
 -- | Penalty for type variables mismatch.
 -- | Congruent types should receive zero penalty points.
 typeVarPenalty :: List Substitution -> Int
@@ -320,6 +328,7 @@ typeVarPenalty substs =
                       _ -> identity
                    ) mempty substs
 
+
 -- | Penalty for name mismatches.
 namesPenalty :: List Substitution -> Int
 namesPenalty = go 0
@@ -335,6 +344,7 @@ namesPenalty = go 0
     go p (RowsMismatch n m : rest) = go (config.penalties.rowsMismatch * abs (n - m)) rest
     go p (_ : rest) = go p rest
 
+
 -- | Penalty for generalization and instantiation.
 mismatchPenalty :: List Substitution -> Int
 mismatchPenalty = go 0
@@ -351,6 +361,7 @@ mismatchPenalty = go 0
     go n (QueryMismatch q     : rest) = go (n + typeQuerySize q)                      rest
     go n (_ : rest) = go n rest
 
+
 -- | Only returns a list of type class names (lists of arguments are omitted).
 joinQueryConstraints :: TypeQuery -> { constraints :: List String
                                      , ty :: TypeQuery }
@@ -360,6 +371,7 @@ joinQueryConstraints = go Nil
       go (name : acc) query
     go acc ty = { constraints: List.sort acc, ty }
 
+
 typeQuerySize :: TypeQuery -> Int
 typeQuerySize = go 0 <<< List.singleton
   where
@@ -379,6 +391,7 @@ typeQuerySize = go 0 <<< List.singleton
     go n (QRow qs : rest) =
       go n       ((qs <#> snd) <> rest)
 
+
 typeSize :: Type -> Int
 typeSize = go 0 <<< List.singleton
   where
diff --git a/src/Docs/Search/TypeShape.purs b/src/Docs/Search/TypeShape.purs
index a97b6fb..d7741a6 100644
--- a/src/Docs/Search/TypeShape.purs
+++ b/src/Docs/Search/TypeShape.purs
@@ -3,11 +3,11 @@
 -- | it on demand.
 module Docs.Search.TypeShape where
 
-import Prelude
-
 import Docs.Search.TypeDecoder (QualifiedName(..), Type(..), joinForAlls, joinRows)
 import Docs.Search.TypeQuery (TypeQuery(..), getFreeVariables)
 
+import Prelude
+
 import Data.Generic.Rep (class Generic)
 import Data.Generic.Rep.Show (genericShow)
 import Data.List (List(..), (:))
@@ -17,8 +17,10 @@ import Data.Set as Set
 import Data.Tuple (Tuple(..), snd)
 import Data.Ord (abs)
 
+
 type TypeShape = List ShapeChunk
 
+
 data ShapeChunk
   = PVar
   | PFun
@@ -33,6 +35,7 @@ derive instance genericShapeChunk :: Generic ShapeChunk _
 instance showShapeChunk :: Show ShapeChunk where
   show x = genericShow x
 
+
 stringifyShape :: TypeShape -> String
 stringifyShape shape =
   show $ abs $ hash
@@ -47,6 +50,7 @@ stringifyShape shape =
         PForAll n -> "b" <> show n
         PRow n    -> "r" <> show n
 
+
 shapeOfTypeQuery :: TypeQuery -> TypeShape
 shapeOfTypeQuery query =
   prependForAll $ List.reverse $ go (pure query) Nil
@@ -80,6 +84,7 @@ shapeOfTypeQuery query =
           let lst' = List.sortBy (\(Tuple x _) (Tuple y _) -> compare x y) lst in
           go (map snd lst' <> rest) (PRow (List.length lst) : acc)
 
+
 shapeOfType :: Type -> TypeShape
 shapeOfType ty = List.reverse $ go (pure ty) Nil
   where
@@ -133,4 +138,5 @@ shapeOfType ty = List.reverse $ go (pure ty) Nil
         BinaryNoParensType op l r ->
           go (TypeApp (TypeApp op l) r : rest) acc
 
+
 foreign import hash :: String -> Int
diff --git a/test/Test/TypeQuery.purs b/test/Test/TypeQuery.purs
index 1f2ec63..4afaafa 100644
--- a/test/Test/TypeQuery.purs
+++ b/test/Test/TypeQuery.purs
@@ -1,12 +1,10 @@
 module Test.TypeQuery where
 
-import Prelude
-
-import Test.Extra (assertRight)
-
+import Docs.Search.TypeDecoder (Constraint(..), QualifiedName(..), Type(..))
 import Docs.Search.TypeQuery (Substitution(..), TypeQuery(..), getFreeVariables, parseTypeQuery, penalty, typeVarPenalty)
-import Docs.Search.TypeShape (ShapeChunk(..), shapeOfTypeQuery)
-import Docs.Search.TypeDecoder (QualifiedName(..), Type(..))
+import Docs.Search.TypeShape (ShapeChunk(..), shapeOfType, shapeOfTypeQuery)
+
+import Prelude
 
 import Data.Foldable (class Foldable)
 import Data.List (List(..), (:))
@@ -15,8 +13,11 @@ import Data.List.NonEmpty (NonEmptyList)
 import Data.List.NonEmpty as NonEmptyList
 import Data.Set as Set
 import Data.Tuple (Tuple(..))
+import Test.Extra (assertRight)
 import Test.Unit (TestSuite, suite, test)
 import Test.Unit.Assert as Assert
+import Data.Maybe (Maybe(..))
+
 
 tests :: TestSuite
 tests = do
@@ -205,6 +206,13 @@ tests = do
       assertRight (parseTypeQuery input)
         (QConstraint "Foldable1" ((QVar "t") : Nil) (QConstraint "Apply" ((QVar "f") : Nil) (QFun (QApp (QVar "t") (QApp (QVar "f") (QVar "a"))) (QApp (QVar "f") (QVar "a")))))
 
+    test "test #35" do
+      let input = "Generic a rep => GenericEq rep => a -> a -> Boolean"
+      assertRight (parseTypeQuery input)
+        (QConstraint "Generic" ((QVar "a") : (QVar "rep") : Nil)
+         (QConstraint "GenericEq" ((QVar "rep") : Nil)
+          (QFun (QVar "a") (QFun (QVar "a") (QConst "Boolean")))))
+
   suite "polish notation" do
 
     test "test #1" do
@@ -230,6 +238,25 @@ tests = do
       assertRight (shapeOfTypeQuery <$> parseTypeQuery input)
           (l [ PForAll 1, PFun, PForAll 1, PApp, PApp, PVar, PVar, PApp, PApp, PVar, PVar, PVar, PApp, PVar, PVar ])
 
+  suite "type shapes" do
+    test "test #1" do
+      let query = "Generic a rep => GenericEq rep => a -> a -> Boolean"
+          c1 = constr (qname [""] "Generic") [TypeVar "a", TypeVar "rep"]
+          c2 = constr (qname [""] "GenericEq") [TypeVar "rep"]
+
+          fun t1 t2 =
+            TypeApp (TypeApp (TypeConstructor (QualifiedName { moduleName: ["Prim"]
+                                                             , name: "Function" })) t1) t2
+          type_ =
+            ForAll "a" Nothing $
+            ForAll "rep" Nothing $
+            ConstrainedType c1
+            (ConstrainedType c2
+             (fun (TypeVar "a") (fun (TypeVar "b")
+                                 (TypeConstructor $ qname ["Prim", "Boolean"] "Boolean"))))
+          shape = shapeOfTypeQuery <$> parseTypeQuery query
+      Assert.equal (pure $ shapeOfType type_) shape
+
   suite "free variable counting" do
 
     test "test #1" do
@@ -370,3 +397,9 @@ unitType = TypeConstructor (QualifiedName { moduleName: []
 
 countFreeVars :: TypeQuery -> Int
 countFreeVars = getFreeVariables >>> Set.size
+
+qname :: Array String -> String -> QualifiedName
+qname m n = QualifiedName { moduleName: m, name: n }
+
+constr :: QualifiedName -> Array Type -> Constraint
+constr c a = Constraint { constraintClass: c, constraintArgs: a }