[DHG_packages] 02/15: hoogle: Remove pre-compiled keyword hoogle database
Ilias Tsitsimpis
iliastsi-guest at moszumanska.debian.org
Sun Oct 30 16:52:28 UTC 2016
This is an automated email from the git hooks/post-receive script.
iliastsi-guest pushed a commit to branch master
in repository DHG_packages.
commit d0a411cadfef5520920027e4801b0d333dba9ea4
Author: Ilias Tsitsimpis <i.tsitsimpis at gmail.com>
Date: Thu Oct 27 22:17:22 2016 +0300
hoogle: Remove pre-compiled keyword hoogle database
This file is not compatible with the latest version of hoogle
and I could find how to generate one. Could it be that the latest
version of Hoogle doesn't index Haskell's keywords?
---
p/haskell-hoogle/debian/README.source | 12 +-
p/haskell-hoogle/debian/changelog | 2 +
p/haskell-hoogle/debian/files_hoogle/keyword.txt | 1116 ----------------------
p/haskell-hoogle/debian/hoogle.dirs | 1 -
p/haskell-hoogle/debian/hoogle.install | 1 -
5 files changed, 3 insertions(+), 1129 deletions(-)
diff --git a/p/haskell-hoogle/debian/README.source b/p/haskell-hoogle/debian/README.source
index 588b2a1..8e5333a 100644
--- a/p/haskell-hoogle/debian/README.source
+++ b/p/haskell-hoogle/debian/README.source
@@ -5,16 +5,6 @@ trick hoogle into working fully offline.
This doesn't offer the full functionality of hoogle (e.g. full package
list is not available), but we do have full local indexing (based on
-what packages are installed) plus the keywords file.
-
-This file (`debian/files_hoogle/keyword.txt`) is being shipped as
-processed by a normal (with access to online resources) hoogle
-database. To regenerate it:
-
-- Create an empty directory and `cd` to it.
-- Run: `hoogle data -d .`; this will take a while as it downloads and
- unpacks things, and then finally generate the default database.
-- You should then have, amongst many other things, a `keyword.txt`
- file in it; simply copy it to `debian/files_hoogle`.
+what packages are installed).
-- Iustin Pop <iustin at debian.org>, Sun, 21 Sep 2014 22:06:10 +0200
diff --git a/p/haskell-hoogle/debian/changelog b/p/haskell-hoogle/debian/changelog
index b3ebb70..979cc5a 100644
--- a/p/haskell-hoogle/debian/changelog
+++ b/p/haskell-hoogle/debian/changelog
@@ -1,6 +1,8 @@
haskell-hoogle (5.0.1-3) UNRELEASED; urgency=medium
* Remove obsolete d/jquery_1.7.2+dfsg.orig.tar.gz file.
+ * Remove pre-compiled keyword hoogle database.
+ This file is not compatible with the latest version of hoogle.
-- Ilias Tsitsimpis <i.tsitsimpis at gmail.com> Fri, 28 Oct 2016 13:02:02 +0300
diff --git a/p/haskell-hoogle/debian/files_hoogle/keyword.txt b/p/haskell-hoogle/debian/files_hoogle/keyword.txt
deleted file mode 100644
index 0cd2f2d..0000000
--- a/p/haskell-hoogle/debian/files_hoogle/keyword.txt
+++ /dev/null
@@ -1,1116 +0,0 @@
--- Hoogle documentation, generated by Hoogle
--- From http://www.haskell.org/haskellwiki/Keywords
--- See Hoogle, http://www.haskell.org/hoogle/
-
--- | Haskell keywords, always available
- at url http://haskell.org/haskellwiki/Keywords
- at package keyword
-
--- | Whenever a data constructor is applied, each argument to the
--- constructor is evaluated if and only if the corresponding type in the
--- algebraic datatype declaration has a strictness flag, denoted by an
--- exclamation point. For example:
---
--- <pre>
--- data STList a
--- = STCons a !(STList a) -- the second argument to STCons will be
--- -- evaluated before STCons is applied
--- | STNil
--- </pre>
---
--- to illustrate the difference between strict versus lazy constructor
--- application, consider the following:
---
--- <pre>
--- stList = STCons 1 undefined
--- lzList = (:) 1 undefined
--- stHead (STCons h _) = h -- this evaluates to undefined when applied to stList
--- lzHead (h : _) = h -- this evaluates to 1 when applied to lzList
--- </pre>
---
--- ! is also used in the "bang patterns" (GHC extension), to indicate
--- strictness in patterns:
---
--- <pre>
--- f !x !y = x + y
--- </pre>
- at url #.21
- at entry keyword !
-
--- | <ul><li>
--- Character literal: 'a'
--- </li><li>
--- Template Haskell: Name of a (value) variable or data constructor:
--- 'length, 'Left
--- </li><li>
--- (in types, GHC specific) Promoted data constructor: 'True
--- </li></ul>
- at url #.27
- at entry keyword '
-
--- | <ul><li>
--- Template Haskell: Name of a type constructor or class: ''Int,
--- ''Either, ''Show
--- </li></ul>
- at url #.27.27
- at entry keyword ''
-
--- | This operator token is magic/irregular in the sense that
---
--- <pre>
--- (- 1)
--- </pre>
---
--- is parsed as the negative integer -1, rather than as an operator
--- section, as it would be for any other operator:
---
--- <pre>
--- (* 1) :: Num a => a -> a
--- </pre>
---
--- <pre>
--- (++ "foo") :: String -> String
--- It is syntactic sugar for the negate function in Prelude. See unary operator.
--- If you want the section, you can use the subtract function or (+(-1)).
--- </pre>
- at url #-
- at entry keyword -
-
--- | <pre>
--- main = print "hello world" -- this is a comment
--- --this is a comment as well
--- ---this too
--- foobar --+ this_is_the_second_argument_of_the_dash_dash_plus_operator
--- The multi-line variant for comments is {- comment -}.
--- </pre>
- at url #--
- at entry keyword --
-
--- | Arrow notation
- at url #-.3C
- at entry keyword -<
-
--- | Arrow notation
---
- at url #-.3C.3C
- at entry keyword -<<
-
--- | <ul><li>
--- The function type constructor:
--- </li></ul>
---
--- <pre>
--- length :: [a] -> Int
--- </pre>
---
--- <ul><li>
--- In lambda functions:
--- </li></ul>
---
--- <pre>
--- \x -> x + 1
--- </pre>
---
--- <ul><li>
--- To denote alternatives in case statements:
--- </li></ul>
---
--- <pre>
--- case Just 3 of
--- Nothing -> False
--- Just x -> True
--- </pre>
---
--- <ul><li>
--- On the kind level (GHC specific):
--- </li></ul>
---
--- <pre>
--- ghci> :kind (->)
--- (->) :: * -> * -> *
--- </pre>
---
--- <ul><li>
--- Functional dependencies
--- </li></ul>
---
--- <pre>
--- -- This examples assumes that each type 'c' can "contain" only one type
--- -- i.e. type 'c' uniquely determines type 'elt'
--- class Contains c elt | c -> elt where
--- ...
--- </pre>
---
--- <ul><li>
--- View patterns
--- </li></ul>
- at url #-.3E
- at entry keyword ->
-
--- | Read as "has type":
---
--- <pre>
--- length :: [a] -> Int
--- </pre>
---
--- "Length has type list-of-'a' to Int"
---
--- Or "has kind" (GHC specific):
---
--- <pre>
--- Either :: * -> * -> *
--- </pre>
- at url #::
- at entry keyword ::
-
--- | <ul><li>
--- Statement separator in an explicit block (see layout)
--- </li></ul>
- at url #.3B
- at entry keyword ;
-
--- | <ul><li>
--- In do-notation, "draw from":
--- </li></ul>
---
--- <pre>
--- do x <- getChar
--- putChar x
--- </pre>
---
--- <ul><li>
--- In list comprehension generators, "in":
--- </li></ul>
---
--- <pre>
--- [ (x,y) | x <- [1..10], y <- ['a'..'z'] ]
--- </pre>
---
--- <ul><li>
--- In pattern guards, "matches":
--- </li></ul>
---
--- <pre>
--- f x y | Just z <- g x = True
--- | otherwise = False
--- </pre>
- at url #.3C-
- at entry keyword <-
-
--- | In list comprehensions, "and":
---
--- <pre>
--- [ (x,y) | x <- [1..10], y <- ['a'..'z'], x > 42 ]
--- </pre>
- at url #.2C
- at entry keyword ,
-
--- | Used in definitions.
---
--- <pre>
--- x = 4
--- </pre>
- at url #.3D
- at entry keyword =
-
--- | Used to indicate instance contexts, for example:
---
--- <pre>
--- sort :: Ord a => [a] -> [a]
--- </pre>
- at url #.3D.3E
- at entry keyword =>
-
--- | In a Bird's style Literate Haskell file, the > character is used to
--- introduce a code line.
---
--- <pre>
--- comment line
---
--- > main = print "hello world"
--- </pre>
- at url #.3E
- at entry keyword >
-
--- | <ul><li>
--- Implicit parameters
--- </li></ul>
---
--- <pre>
--- ghci> :t ?foo ++ "bar"
--- ?foo ++ "bar" :: (?foo::[Char]) => [Char]
--- </pre>
- at url #.3F
- at entry keyword ?
-
--- | <ul><li>
--- MagicHash
--- </li></ul>
---
--- <ul><li>
--- On the kind level: The kind of unboxed types (GHC-specific)
--- </li></ul>
---
--- <pre>
--- ghci> :m +GHC.Prim
--- ghci> :set -XMagicHash
--- ghci> :kind Int#
--- Int# :: #
--- </pre>
- at url #.23
- at entry keyword #
-
--- | <ul><li>
--- Is an ordinary operator name on the value level
--- </li></ul>
---
--- <ul><li>
--- On the kind level: The kind of boxed types (GHC-specific)
--- </li></ul>
---
--- <pre>
--- ghci> :kind Int
--- Int :: *
--- </pre>
- at url #.2A
- at entry keyword *
-
--- | Patterns of the form var at pat are called as-patterns, and allow one to
--- use var as a name for the value being matched by pat. For example:
---
--- <pre>
--- case e of { xs@(x:rest) -> if x==0 then rest else xs }
--- </pre>
---
--- is equivalent to:
---
--- <pre>
--- let { xs = e } in
--- case xs of { (x:rest) -> if x==0 then rest else xs }
--- </pre>
- at url #.40
- at entry keyword @
-
--- | <ul><li>
--- Template Haskell
--- </li></ul>
---
--- <ul><li>
--- Expression quotation: [| print 1 |]
--- </li><li>
--- Declaration quotation: [d| main = print 1 |]
--- </li><li>
--- Type quotation: [t| Either Int () |]
--- </li><li>
--- Pattern quotation: [p| (x,y) |]
--- </li><li>
--- Quasiquotation: [nameOfQuasiQuoter| ... |]
--- </li></ul>
- at url #.5B.7C
- at entry keyword [|
-
--- | <ul><li>
--- Template Haskell
--- </li></ul>
---
--- <ul><li>
--- Expression quotation: [| print 1 |]
--- </li><li>
--- Declaration quotation: [d| main = print 1 |]
--- </li><li>
--- Type quotation: [t| Either Int () |]
--- </li><li>
--- Pattern quotation: [p| (x,y) |]
--- </li><li>
--- Quasiquotation: [nameOfQuasiQuoter| ... |]
--- </li></ul>
- at url #.7C.5D
- at entry keyword |]
-
--- | The backslash "\" is used
---
--- <ul><li>
--- in multiline strings
--- </li></ul>
---
--- <pre>
--- "foo\
--- \bar"
--- </pre>
---
--- <ul><li>
--- in lambda functions
--- </li></ul>
---
--- <pre>
--- \x -> x + 1
--- </pre>
---
- at url #.5C
- at entry keyword \
-
--- | A function enclosed in back ticks "`" can be used as an infix
--- operator.
---
--- <pre>
--- 2 `subtract` 10
--- </pre>
---
--- is the same as
---
--- <pre>
--- subtract 2 10
--- </pre>
- at url #.60
- at entry keyword `
-
--- | <ul><li>
--- Explicit block (disable layout), possibly with ";" .
--- </li></ul>
---
--- <ul><li>
--- Record update notation
--- </li></ul>
---
--- <pre>
--- changePrice :: Thing -> Price -> Thing
--- changePrice x new = x { price = new }
--- </pre>
---
--- <ul><li>
--- Comments (see below)
--- </li></ul>
- at url #.7B
- at entry keyword {
-
--- | <ul><li>
--- Explicit block (disable layout), possibly with ";" .
--- </li></ul>
---
--- <ul><li>
--- Record update notation
--- </li></ul>
---
--- <pre>
--- changePrice :: Thing -> Price -> Thing
--- changePrice x new = x { price = new }
--- </pre>
---
--- <ul><li>
--- Comments (see below)
--- </li></ul>
- at url #.7D
- at entry keyword }
-
--- | Everything between "{-" followed by a space and "-}" is a block
--- comment.
---
--- <pre>
--- {-
--- hello
--- world
--- -}
--- </pre>
- at url #.7B-
- at entry keyword {-
-
--- | Everything between "{-" followed by a space and "-}" is a block
--- comment.
---
--- <pre>
--- {-
--- hello
--- world
--- -}
--- </pre>
- at url #-.7D
- at entry keyword -}
-
--- | The "pipe" is used in several places
---
--- <ul><li>
--- Data type definitions, "or"
--- </li></ul>
---
--- <pre>
--- data Maybe a = Just a | Nothing
--- </pre>
---
--- <ul><li>
--- List comprehensions, "for" (as in, "list of <tt>a*a</tt> for
--- <tt>a</tt> in <tt>[1..]</tt>)
--- </li></ul>
---
--- <pre>
--- squares = [a*a | a <- [1..]]
--- </pre>
---
--- <ul><li>
--- Guards, "when"
--- </li></ul>
---
--- <pre>
--- safeTail x | null x = []
--- | otherwise = tail x
--- </pre>
---
--- <ul><li>
--- Functional dependencies, "where"
--- </li></ul>
---
--- <pre>
--- class Contains c elt | c -> elt where
--- ...
--- </pre>
- at url #.7C
- at entry keyword |
-
--- | <ul><li>
--- Lazy pattern bindings. Matching the pattern ~pat against a value
--- always
--- </li></ul>
---
--- succeeds, and matching will only diverge when one of the variables
--- bound in the pattern is used.
---
--- <pre>
--- f1, f2 :: Maybe Int -> String
--- f1 x = case x of
--- Just n -> "Got it"
--- f2 x = case x of
--- ~(Just n) -> "Got it"
---
--- (+++), (++++) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d)
--- (f +++ g) ~(x, y) = (f x, g y)
--- (f ++++ g) (x, y) = (f x, g y)
--- </pre>
---
--- Then we have:
---
--- <pre>
--- f1 Nothing
--- Exception: Non-exhaustive patterns in case
---
--- f2 Nothing
--- "Got it"
---
--- (const 1 +++ const 2) undefined
--- (1,2)
---
--- (const 1 ++++ const 2) undefined
--- Exception: Prelude.undefined
--- </pre>
---
--- For more details see the Haskell Wikibook.
---
--- <ul><li>
--- Equality constraints. Assert that two types in a context must be the
--- same:
--- </li></ul>
---
--- <pre>
--- example :: F a ~ b => a -> b
--- </pre>
---
--- Here the type "F a" must be the same as the type "b", which allows
--- one to constrain polymorphism (especially where type families are
--- involved), but to a lesser extent than functional dependencies. See
--- Type Families.
- at url #.7E
- at entry keyword ~
-
--- | <pre>
--- import qualified Data.Map as M
---
--- main = print (M.empty :: M.Map Int ())
--- </pre>
- at url #as
- at entry keyword as
-
--- | A case expression has the general form
---
--- <pre>
--- case e of { p1 match1 ; ... ; pn matchn }
--- </pre>
---
--- where each <tt>match</tt>i is of the general form
---
--- <pre>
--- | g1 -> e1
--- ...
--- | gm -> em
--- where decls
--- </pre>
---
--- Each alternative consists of patterns <tt>p</tt>i and their matches,
--- <tt>match</tt>i. Each<tt>match</tt>i in turn consists of a sequence of
--- pairs of guards <tt>g</tt>ij and bodies <tt>e</tt>ij (expressions),
--- followed by optional bindings (<tt>decls</tt>i) that scope over all of
--- the guards and expressions of the alternative. An alternative of the
--- form
---
--- <pre>
--- pat -> exp where decls
--- </pre>
---
--- is treated as shorthand for:
---
--- <pre>
--- pat | True -> exp
--- where decls
--- </pre>
---
--- A case expression must have at least one alternative and each
--- alternative must have at least one body. Each body must have the same
--- type, and the type of the whole expression is that type.
---
--- A case expression is evaluated by pattern matching the expression
--- <tt>e</tt> against the individual alternatives. The alternatives are
--- tried sequentially, from top to bottom. If <tt>e</tt> matches the
--- pattern in the alternative, the guards for that alternative are tried
--- sequentially from top to bottom, in the environment of the case
--- expression extended first by the bindings created during the matching
--- of the pattern, and then by the <tt>decls</tt>i in the <tt>where</tt>
--- clause associated with that alternative. If one of the guards
--- evaluates to <tt>True</tt>, the corresponding right-hand side is
--- evaluated in the same environment as the guard. If all the guards
--- evaluate to <tt>False</tt>, matching continues with the next
--- alternative. If no match succeeds, the result is _|_.
- at url #case
- at entry keyword case
-
--- | A case expression has the general form
---
--- <pre>
--- case e of { p1 match1 ; ... ; pn matchn }
--- </pre>
---
--- where each <tt>match</tt>i is of the general form
---
--- <pre>
--- | g1 -> e1
--- ...
--- | gm -> em
--- where decls
--- </pre>
---
--- Each alternative consists of patterns <tt>p</tt>i and their matches,
--- <tt>match</tt>i. Each<tt>match</tt>i in turn consists of a sequence of
--- pairs of guards <tt>g</tt>ij and bodies <tt>e</tt>ij (expressions),
--- followed by optional bindings (<tt>decls</tt>i) that scope over all of
--- the guards and expressions of the alternative. An alternative of the
--- form
---
--- <pre>
--- pat -> exp where decls
--- </pre>
---
--- is treated as shorthand for:
---
--- <pre>
--- pat | True -> exp
--- where decls
--- </pre>
---
--- A case expression must have at least one alternative and each
--- alternative must have at least one body. Each body must have the same
--- type, and the type of the whole expression is that type.
---
--- A case expression is evaluated by pattern matching the expression
--- <tt>e</tt> against the individual alternatives. The alternatives are
--- tried sequentially, from top to bottom. If <tt>e</tt> matches the
--- pattern in the alternative, the guards for that alternative are tried
--- sequentially from top to bottom, in the environment of the case
--- expression extended first by the bindings created during the matching
--- of the pattern, and then by the <tt>decls</tt>i in the <tt>where</tt>
--- clause associated with that alternative. If one of the guards
--- evaluates to <tt>True</tt>, the corresponding right-hand side is
--- evaluated in the same environment as the guard. If all the guards
--- evaluate to <tt>False</tt>, matching continues with the next
--- alternative. If no match succeeds, the result is _|_.
- at url #of
- at entry keyword of
-
--- | A class declaration introduces a new type class and the overloaded
--- operations that must be supported by any type that is an instance of
--- that class.
---
--- <pre>
--- class Num a where
--- (+) :: a -> a -> a
--- negate :: a -> a
--- </pre>
- at url #class
- at entry keyword class
-
--- | The data declaration is how one introduces new algebraic data types
--- into Haskell. For example:
---
--- <pre>
--- data Set a = NilSet
--- | ConsSet a (Set a)
--- </pre>
---
--- Another example, to create a datatype to hold an abstract syntax tree
--- for an expression, one could use:
---
--- <pre>
--- data Exp = Ebin Operator Exp Exp
--- | Eunary Operator Exp
--- | Efun FunctionIdentifier [Exp]
--- | Eid SimpleIdentifier
--- </pre>
---
--- where the types <tt>Operator, FunctionIdentifier</tt> and
--- <tt>SimpleIdentifier</tt> are defined elsewhere.
---
--- See the page on types for more information, links and examples.
- at url #data
- at entry keyword data
-
--- | Declares a datatype family (see type families). GHC language
--- extension.
- at url #data_family
- at entry keyword data family
-
--- | Declares a datatype family instance (see type families). GHC language
--- extension.
---
- at url #data_instance
- at entry keyword data instance
-
--- | Ambiguities in the class Num are most common, so Haskell provides a
--- way to resolve them---with a default declaration:
---
--- <pre>
--- default (Int)
--- </pre>
---
--- Only one default declaration is permitted per module, and its effect
--- is limited to that module. If no default declaration is given in a
--- module then it assumed to be:
---
--- <pre>
--- default (Integer, Double)
--- </pre>
- at url #default
- at entry keyword default
-
--- | data and newtype declarations contain an optional deriving form. If
--- the form is included, then derived instance declarations are
--- automatically generated for the datatype in each of the named classes.
---
--- Derived instances provide convenient commonly-used operations for
--- user-defined datatypes. For example, derived instances for datatypes
--- in the class Eq define the operations == and /=, freeing the
--- programmer from the need to define them.
---
--- <pre>
--- data T = A
--- | B
--- | C
--- deriving (Eq, Ord, Show)
--- </pre>
---
--- In the case of newtypes, GHC extends this mechanism to Cunning
--- Newtype Deriving.
- at url #deriving
- at entry keyword deriving
-
--- | Standalone deriving (GHC language extension).
---
--- <pre>
--- {-# LANGUAGE StandaloneDeriving #-}
--- data A = A
---
--- deriving instance Show A
--- </pre>
- at url #deriving_instance
- at entry keyword deriving instance
-
--- | Syntactic sugar for use with monadic expressions. For example:
---
--- <pre>
--- do { x ; result <- y ; foo result }
--- </pre>
---
--- is shorthand for:
---
--- <pre>
--- x >>
--- y >>= \result ->
--- foo result
--- </pre>
- at url #do
- at entry keyword do
-
--- | This is a GHC/Hugs extension, and as such is not portable Haskell
--- 98/2010. It is only a reserved word within types.
---
--- Type variables in a Haskell type expression are all assumed to be
--- universally quantified; there is no explicit syntax for universal
--- quantification, in standard Haskell 98/2010. For example, the type
--- expressiona -> a denotes the type forall a. a ->a.
---
--- For clarity, however, we often write quantification explicitly when
--- discussing the types of Haskell programs. When we write an explicitly
--- quantified type, the scope of the forall extends as far to the right
--- as possible; for example,
---
--- <pre>
--- forall a. a -> a
--- </pre>
---
--- means
---
--- <pre>
--- forall a. (a -> a)
--- GHC introduces a forall keyword, allowing explicit quantification, for example, to encode
--- </pre>
---
--- existential types:
---
--- <pre>
--- data Foo = forall a. MkFoo a (a -> Bool)
--- | Nil
---
--- MkFoo :: forall a. a -> (a -> Bool) -> Foo
--- Nil :: Foo
---
--- [MkFoo 3 even, MkFoo 'c' isUpper] :: [Foo]
--- </pre>
- at url #forall
- at entry keyword forall
-
- at url #foreign
- at entry keyword foreign
-
--- | When importing modules, without introducing a name into scope,
--- entities can be excluded by using the form
---
--- <pre>
--- hiding (import1 , ... , importn )
--- </pre>
---
--- which specifies that all entities exported by the named module should
--- be imported except for those named in the list.
---
--- For example:
---
--- <pre>
--- import Prelude hiding (lookup,filter,foldr,foldl,null,map)
--- </pre>
- at url #hiding
- at entry keyword hiding
-
--- | A conditional expression has the form:
---
--- <pre>
--- if e1 then e2 else e3
--- </pre>
---
--- and returns the value of e2 if the value of e1 is True, e3 if e1 is
--- False, and _|_ otherwise.
---
--- <pre>
--- max a b = if a > b then a else b
--- </pre>
- at url #if
- at entry keyword if
-
--- | A conditional expression has the form:
---
--- <pre>
--- if e1 then e2 else e3
--- </pre>
---
--- and returns the value of e2 if the value of e1 is True, e3 if e1 is
--- False, and _|_ otherwise.
---
--- <pre>
--- max a b = if a > b then a else b
--- </pre>
- at url #then
- at entry keyword then
-
--- | A conditional expression has the form:
---
--- <pre>
--- if e1 then e2 else e3
--- </pre>
---
--- and returns the value of e2 if the value of e1 is True, e3 if e1 is
--- False, and _|_ otherwise.
---
--- <pre>
--- max a b = if a > b then a else b
--- </pre>
- at url #else
- at entry keyword else
-
--- | Modules may reference other modules via explicit import declarations,
--- each giving the name of a module to be imported and specifying its
--- entities to be imported.
---
--- For example:
---
--- <pre>
--- module Main where
--- import A
--- import B
--- main = A.f >> B.f
---
--- module A where
--- f = ...
---
--- module B where
--- f = ...
--- </pre>
---
--- See also as, hiding , qualified and the page Import
- at url #import
- at entry keyword import
-
--- | A fixity declaration gives the fixity and binding precedence of one
--- or more operators. The integer in a fixity declaration must be in the
--- range 0 to 9. A fixity declaration may appear anywhere that a type
--- signature appears and, like a type signature, declares a property of a
--- particular operator.
---
--- There are three kinds of fixity, non-, left- and right-associativity
--- (infix, infixl, and infixr, respectively), and ten precedence levels,
--- 0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
--- tightly).
---
--- <pre>
--- module Bar where
--- infixr 7 `op`
--- op = ...
--- </pre>
- at url #infix
- at entry keyword infix
-
--- | A fixity declaration gives the fixity and binding precedence of one
--- or more operators. The integer in a fixity declaration must be in the
--- range 0 to 9. A fixity declaration may appear anywhere that a type
--- signature appears and, like a type signature, declares a property of a
--- particular operator.
---
--- There are three kinds of fixity, non-, left- and right-associativity
--- (infix, infixl, and infixr, respectively), and ten precedence levels,
--- 0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
--- tightly).
---
--- <pre>
--- module Bar where
--- infixr 7 `op`
--- op = ...
--- </pre>
- at url #infixl
- at entry keyword infixl
-
--- | A fixity declaration gives the fixity and binding precedence of one
--- or more operators. The integer in a fixity declaration must be in the
--- range 0 to 9. A fixity declaration may appear anywhere that a type
--- signature appears and, like a type signature, declares a property of a
--- particular operator.
---
--- There are three kinds of fixity, non-, left- and right-associativity
--- (infix, infixl, and infixr, respectively), and ten precedence levels,
--- 0 to 9 inclusive (level 0 binds least tightly, and level 9 binds most
--- tightly).
---
--- <pre>
--- module Bar where
--- infixr 7 `op`
--- op = ...
--- </pre>
- at url #infixr
- at entry keyword infixr
-
--- | An instance declaration declares that a type is an instance of a
--- class and includes the definitions of the overloaded operations -
--- called class methods - instantiated on the named type.
---
--- <pre>
--- instance Num Int where
--- x + y = addInt x y
--- negate x = negateInt x
--- </pre>
- at url #instance
- at entry keyword instance
-
--- | Let expressions have the general form:
---
--- <pre>
--- let { d1 ; ... ; dn } in e
--- </pre>
---
--- They introduce a nested, lexically-scoped, mutually-recursive list of
--- declarations (let is often called letrec in other languages). The
--- scope of the declarations is the expression e and the right hand side
--- of the declarations. Within do-blocks or list comprehensions let { d1
--- ; ... ; dn } without in serves to indroduce local bindings.
- at url #let
- at entry keyword let
-
--- | Let expressions have the general form:
---
--- <pre>
--- let { d1 ; ... ; dn } in e
--- </pre>
---
--- They introduce a nested, lexically-scoped, mutually-recursive list of
--- declarations (let is often called letrec in other languages). The
--- scope of the declarations is the expression e and the right hand side
--- of the declarations. Within do-blocks or list comprehensions let { d1
--- ; ... ; dn } without in serves to indroduce local bindings.
- at url #in
- at entry keyword in
-
- at url #mdo
- at entry keyword mdo
-
--- | Taken from: A Gentle Introduction to Haskell, Version 98
---
--- Technically speaking, a module is really just one big declaration
--- which begins with the keyword module; here's an example for a module
--- whose name is Tree:
---
--- <pre>
--- module Tree ( Tree(Leaf,Branch), fringe ) where
---
--- data Tree a = Leaf a | Branch (Tree a) (Tree a)
---
--- fringe :: Tree a -> [a]
--- fringe (Leaf x) = [x]
--- fringe (Branch left right) = fringe left ++ fringe right
--- </pre>
- at url #module
- at entry keyword module
-
--- | The <tt>newtype</tt> declaration is how one introduces a renaming for
--- an algebraic data type into Haskell. This is different from
--- <tt>type</tt> below, as a <tt>newtype</tt> requires a new constructor
--- as well. As an example, when writing a compiler one sometimes further
--- qualifies <tt>Identifier</tt>s to assist in type safety checks:
---
--- <pre>
--- newtype SimpleIdentifier = SimpleIdentifier Identifier
--- newtype FunctionIdentifier = FunctionIdentifier Identifier
--- </pre>
---
--- Most often, one supplies smart constructors and destructors for these
--- to ease working with them.
---
--- See the page on types for more information, links and examples.
---
--- For the differences between <tt>newtype</tt> and <tt>data</tt>, see
--- Newtype.
- at url #newtype
- at entry keyword newtype
-
--- | proc (arrow abstraction) is a kind of lambda, except that it
--- constructs an arrow instead of a function.
---
--- Arrow notation
- at url #proc
- at entry keyword proc
-
--- | Used to import a module, but not introduce a name into scope. For
--- example, Data.Map exports lookup, which would clash with the Prelude
--- version of lookup, to fix this:
---
--- <pre>
--- import qualified Data.Map
---
--- f x = lookup x -- use the Prelude version
--- g x = Data.Map.lookup x -- use the Data.Map version
--- </pre>
---
--- Of course, Data.Map is a bit of a mouthful, so qualified also allows
--- the use of as.
---
--- <pre>
--- import qualified Data.Map as M
---
--- f x = lookup x -- use Prelude version
--- g x = M.lookup x -- use Data.Map version
--- </pre>
- at url #qualified
- at entry keyword qualified
-
--- | The rec keyword can be used when the <tt>-XDoRec</tt> flag is given;
--- it allows recursive bindings in a do-block.
---
--- <pre>
--- {-# LANGUAGE DoRec #-}
--- justOnes = do { rec { xs <- Just (1:xs) }
--- ; return (map negate xs) }
--- </pre>
- at url #rec
- at entry keyword rec
-
--- | The <tt>type</tt> declaration is how one introduces an alias for an
--- algebraic data type into Haskell. As an example, when writing a
--- compiler one often creates an alias for identifiers:
---
--- <pre>
--- type Identifier = String
--- </pre>
---
--- This allows you to use <tt>Identifer</tt> wherever you had used
--- <tt>String</tt> and if something is of type <tt>Identifier</tt> it may
--- be used wherever a <tt>String</tt> is expected.
---
--- See the page on types for more information, links and examples.
---
--- Some common <tt>type</tt> declarations in the Prelude include:
---
--- <pre>
--- type FilePath = String
--- type String = [Char]
--- type Rational = Ratio Integer
--- type ReadS a = String -> [(a,String)]
--- type ShowS = String -> String
--- </pre>
- at url #type
- at entry keyword type
-
--- | Declares a type synonym family (see type families). GHC language
--- extension.
- at url #type_family
- at entry keyword type family
-
--- | Declares a type synonym family instance (see type families). GHC
--- language extension.
---
- at url #type_instance
- at entry keyword type instance
-
--- | Used to introduce a module, instance, class or GADT:
---
--- <pre>
--- module Main where
---
--- class Num a where
--- ...
---
--- instance Num Int where
--- ...
---
--- data Something a where
--- ...
--- </pre>
---
--- And to bind local variables:
---
--- <pre>
--- f x = y
--- where y = x * 2
---
--- g z | z > 2 = y
--- where y = x * 2
--- </pre>
- at url #where
- at entry keyword where
diff --git a/p/haskell-hoogle/debian/hoogle.dirs b/p/haskell-hoogle/debian/hoogle.dirs
index de65353..491e680 100644
--- a/p/haskell-hoogle/debian/hoogle.dirs
+++ b/p/haskell-hoogle/debian/hoogle.dirs
@@ -1,6 +1,5 @@
usr/bin
usr/sbin
-usr/share/hoogle/predownload
usr/share/hoogle/tool
var/lib/hoogle/databases
var/www
diff --git a/p/haskell-hoogle/debian/hoogle.install b/p/haskell-hoogle/debian/hoogle.install
index f321db2..57e8782 100644
--- a/p/haskell-hoogle/debian/hoogle.install
+++ b/p/haskell-hoogle/debian/hoogle.install
@@ -1,5 +1,4 @@
debian/files_hoogle/hoogle.conf /etc/apache2/conf-available/
debian/files_hoogle/hoogle.png /usr/share/hoogle/resources/
-debian/files_hoogle/keyword.txt /usr/share/hoogle/predownload/
debian/tmp-inst-*/usr/bin/* /usr/bin/
debian/tmp-inst-*/usr/share/hoogle/* /usr/share/hoogle/
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-haskell/DHG_packages.git
More information about the Pkg-haskell-commits
mailing list