O(n) Like a combination of map and foldl'. Applies a function to each element of a Text, passing an accumulating parameter from left to right, and returns a final Text. Performs replacement on invalid scalar values. \n",
+ "
(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)\n",
+ "
contrazip2 ∷ Divisible f ⇒ f a1 → f a2 → f (a1, a2)\n",
+ "
contrazip2 ∷ ∀ f a1 a2 . Divisible f ⇒ f a1 → f a2 → f (a1, a2)\n",
+ "
pair ∷ Sized f ⇒ f a → f b → f (a, b)Default:
pair a b = (,) $ a * b.\n",
"
\n",
- "
mapAccumR ∷ (a → Char → (a, Char)) → a → Text → (a, Text)(package text, module Data.Text)The mapAccumR function behaves like a combination of map and a strict foldr; it applies a function to each element of a Text, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new Text. Performs replacement on invalid scalar values. \n",
- "
\n",
- "
\n",
- "
execRWS ∷ RWS r w s a → r → s → (s, w)(package transformers, module Control.Monad.Trans.RWS.Lazy)Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value. \n",
- "
\n",
- "
\n",
- "
breakSubstring ∷ ByteString → ByteString → (ByteString, ByteString)(package bytestring, module Data.ByteString)otherwise -> Just (length x) \n",
- "
\n",
- "
\n",
- "
For example, to tokenise a string, dropping delimiters:\n",
- "
\n",
- "
\n",
- "
> tokenise x y = h (:) if null t then [] else tokenise x (drop (length x) t)\n",
- "> \n",
- "
\n",
- "
\n",
- "
To skip to the first occurence of a string:\n",
- "
\n",
- "
\n",
- "
> snd (breakSubstring x y)\n",
- "
\n",
- "
\n",
- "
To take the parts of a string before a delimiter:\n",
- "
\n",
- "
\n",
- "
> fst (breakSubstring x y) \n",
- "
\n",
- "
\n",
- "
breakOn ∷ Text → Text → (Text, Text)(package text, module Data.Text)O(n+m) Find the first instance of needle (which must be non-null) in haystack. The first element of the returned tuple is the prefix of haystack before needle is matched. The second is the remainder of haystack, starting with the match.\n",
- "
\n",
- "
\n",
- "
Examples:\n",
- "
\n",
- "
\n",
- "
> breakOn \"::\" \"a::b::c\" ==> (\"a\", \"::b::c\")\n",
- "> breakOn \"/\" \"foobar\" ==> (\"foobar\", \"\")\n",
- "
\n",
- "
\n",
- "
Laws:\n",
- "
\n",
- "
\n",
- "
> append prefix match == haystack\n",
- "> \n",
- "
\n",
- "
\n",
- "
If you need to break a string by a substring repeatedly (e.g. you want to break on every instance of a substring), use breakOnAll instead, as it has lower startup overhead.\n",
- "
\n",
- "
\n",
- "
In (unlikely) bad cases, this function's time complexity degrades towards O(n*m). \n",
- "
\n",
- "
\n"
- ],
- "text/plain": [
- "zip :: [a] -> [b] -> [(a, b)]\n",
- "URL: http://hackage.haskell.org/packages/archive/base/latest/doc/html/Prelude.html#v:zip\n",
- "zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded. \n",
- "(>*<) :: Monoidal f => f a -> f b -> f (a, b)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString-Builder-Prim.html#v:-62--42--60-\n",
- "A pairing/concatenation operator for builder primitives, both bounded and fixed size.\n",
+ "
(>*<) ∷ Monoidal f ⇒ f a → f b → f (a, b)A pairing/concatenation operator for builder primitives, both bounded\n",
+ "and fixed size.\n",
"\n",
"For example,\n",
"\n",
- "> toLazyByteString (primFixed (char7 >*< char7) ('x','y')) = \"xy\"\n",
+ "
\n",
+ "toLazyByteString (primFixed (char7 >*< char7) ('x','y')) = \"xy\"\n",
+ "\n",
"\n",
- "We can combine multiple primitives using >*< multiple times.\n",
+ "We can combine multiple primitives using
>*< multiple\n",
+ "times.\n",
"\n",
- "> toLazyByteString (primFixed (char7 >*< char7 >*< char7) ('x',('y','z'))) = \"xyz\" \n",
- "shrinkState :: ShrinkState s a => a -> s -> [(a, s)]\n",
- "URL: http://hackage.haskell.org/packages/archive/QuickCheck/latest/doc/html/Test-QuickCheck-Modifiers.html#v:shrinkState\n",
+ "
\n",
+ "toLazyByteString (primFixed (char7 >*< char7 >*< char7) ('x',('y','z'))) = \"xyz\"\n",
+ "\n",
+ "
\n",
+ "
(>*<) ∷ Monoidal f ⇒ f a → f b → f (a, b)Merge two functors into a tuple, analogous to
liftA2\n",
+ "(,). (Sometimes known as
**.)\n",
+ "
\n",
+ "
zip ∷ List l ⇒ l a → l b → l (a, b)\n",
+ "
zip ∷ Zip f ⇒ f a → f b → f (a, b)\n",
+ "
zip ∷ (Zip f) ⇒ f a → f b → f (a, b)\n",
+ "
zip ∷ Zip f ⇒ f a → f b → f (a, b)\n",
+ "
zip ∷ Zip f ⇒ f a → f b → f (a, b)\n",
+ "
mzip ∷ MonadZip m ⇒ m a → m b → m (a, b)\n",
+ "
projectZip ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)Zipping projections.\n",
+ "
\n",
+ "
(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)\n",
+ "
projectZip ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)Zipping projections.\n",
+ "
\n",
+ "
(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)\n",
+ "
(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)\n",
+ "
biunfold ∷ (Biunfoldable t, Unfolder f) ⇒ f a → f b → f (t a b)Given a way to generate elements, return a way to generate structures\n",
+ "containing those elements.\n",
+ "
\n",
+ "
biunfoldBF ∷ (Biunfoldable t, Unfolder f) ⇒ f a → f b → f (t a b)Breadth-first unfold, which orders the result by the number of\n",
+ "
choose calls.\n",
+ "
\n",
+ "
deserializeWith2 ∷ (Serial2 f, MonadGet m) ⇒ m a → m b → m (f a b)\n",
+ "
biunfoldRestrict ∷ (BiunfoldableR predA predB t, predA a, predB b, Unfolder f) ⇒ f a → f b → f (t a b)\n",
+ "
biunfoldRestrictBF ∷ (BiunfoldableR p q t, Unfolder f, p a, q b) ⇒ f a → f b → f (t a b)\n",
+ "
mesh ∷ Graph g ⇒ [a] → [b] → g (a, b)Construct a
mesh graph from two lists of vertices. Complexity:\n",
+ "
O(L1 * L2) time, memory and size, where
L1 and
L2\n",
+ "are the lengths of the given lists.\n",
"\n",
- "breakOnAll :: Text -> Text -> [(Text, Text)]\n",
- "URL: http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text.html#v:breakOnAll\n",
- "O(n+m) Find all non-overlapping instances of needle in haystack. Each element of the returned list consists of a pair:\n",
+ "
\n",
+ "mesh xs [] == empty\n",
+ "mesh [] ys == empty\n",
+ "mesh [x] [y] == vertex (x, y)\n",
+ "mesh xs ys == box (path xs) (path ys)\n",
+ "mesh [1..3] \"ab\" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(2,'b')), ((2,'a'),(2,'b'))\n",
+ ", ((2,'a'),(3,'a')), ((2,'b'),(3,'b')), ((3,'a'),(3,'b')) ]\n",
+ "
\n",
+ "
\n",
+ "
torus ∷ Graph g ⇒ [a] → [b] → g (a, b)Construct a
torus graph from two lists of vertices. Complexity:\n",
+ "
O(L1 * L2) time, memory and size, where
L1 and
L2\n",
+ "are the lengths of the given lists.\n",
"\n",
- "* The entire string prior to the kth match (i.e. the prefix)\n",
- "* The kth match, followed by the remainder of the string\n",
+ "
\n",
+ "torus xs [] == empty\n",
+ "torus [] ys == empty\n",
+ "torus [x] [y] == edge (x,y) (x,y)\n",
+ "torus xs ys == box (circuit xs) (circuit ys)\n",
+ "torus [1,2] \"ab\" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(1,'a')), ((1,'b'),(2,'b'))\n",
+ ", ((2,'a'),(1,'a')), ((2,'a'),(2,'b')), ((2,'b'),(1,'b')), ((2,'b'),(2,'a')) ]\n",
+ "
\n",
+ "
\n",
+ "
zipExactMay ∷ [a] → [b] → Maybe [(a, b)]\n"
+ ],
+ "text/plain": [
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/base/docs/Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
"\n",
- "Examples:\n",
+ "
\n",
+ "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
+ "
\n",
"\n",
- "> breakOnAll \"::\" \"\"\n",
- "> ==> []\n",
- "> breakOnAll \"/\" \"a/b/c/\"\n",
- "> ==> [(\"a\", \"/b/c/\"), (\"a/b\", \"/c/\"), (\"a/b/c\", \"/\")]\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded:\n",
"\n",
- "In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).\n",
+ "
\n",
+ "zip [1] ['a', 'b'] = [(1, 'a')]\n",
+ "zip [1, 2] ['a'] = [(1, 'a')]\n",
+ "
\n",
"\n",
- "The needle parameter may not be empty. \n",
- "breakOnAll :: Text -> Text -> [(Text, Text)]\n",
- "URL: http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text-Lazy.html#v:breakOnAll\n",
- "O(n+m) Find all non-overlapping instances of needle in haystack. Each element of the returned list consists of a pair:\n",
+ "
zip is right-lazy:\n",
"\n",
- "* The entire string prior to the kth match (i.e. the prefix)\n",
- "* The kth match, followed by the remainder of the string\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "zip _|_ [] = _|_\n",
+ "
\n",
"\n",
- "Examples:\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/base/docs/Data-List.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
"\n",
- "> breakOnAll \"::\" \"\"\n",
- "> ==> []\n",
- "> breakOnAll \"/\" \"a/b/c/\"\n",
- "> ==> [(\"a\", \"/b/c/\"), (\"a/b\", \"/c/\"), (\"a/b/c\", \"/\")]\n",
+ "
\n",
+ "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
+ "
\n",
"\n",
- "This function is strict in its first argument, and lazy in its second.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded:\n",
"\n",
- "In (unlikely) bad cases, this function's time complexity degrades towards O(n*m).\n",
+ "
\n",
+ "zip [1] ['a', 'b'] = [(1, 'a')]\n",
+ "zip [1, 2] ['a'] = [(1, 'a')]\n",
+ "
\n",
"\n",
- "The needle parameter may not be empty. \n",
- "genLNodes :: Enum a => a -> Int -> [LNode a]\n",
- "URL: http://hackage.haskell.org/packages/archive/fgl/latest/doc/html/Data-Graph-Inductive-Example.html#v:genLNodes\n",
- "generate list of labeled nodes \n",
- "gmapAccumT :: Data d => (forall e. Data e => a -> e -> (a, e)) -> a -> d -> (a, d)\n",
- "URL: http://hackage.haskell.org/packages/archive/syb/latest/doc/html/Data-Generics-Twins.html#v:gmapAccumT\n",
- "gmapT with accumulation \n",
- "threadList :: (Collect r c) -> (Split t i r) -> [i] -> t -> (c, t)\n",
- "URL: http://hackage.haskell.org/packages/archive/fgl/latest/doc/html/Data-Graph-Inductive-Internal-Thread.html#v:threadList\n",
+ "
zip is right-lazy:\n",
"\n",
- "threadList' :: (Collect r c) -> (Split t i r) -> [i] -> t -> (c, t)\n",
- "URL: http://hackage.haskell.org/packages/archive/fgl/latest/doc/html/Data-Graph-Inductive-Internal-Thread.html#v:threadList-39-\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "zip _|_ [] = _|_\n",
+ "
\n",
"\n",
- "mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString-Lazy.html#v:mapAccumL\n",
- "The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString. \n",
- "mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html#v:mapAccumL\n",
- "The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list. \n",
- "mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html#v:mapAccumR\n",
- "The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString. \n",
- "mapAccumL :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString-Lazy-Char8.html#v:mapAccumL\n",
- "The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new ByteString. \n",
- "mapAccumL :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString-Char8.html#v:mapAccumL\n",
- "The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a ByteString, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list. \n",
- "mapAccumR :: (acc -> Char -> (acc, Char)) -> acc -> ByteString -> (acc, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString-Char8.html#v:mapAccumR\n",
- "The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a ByteString, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new ByteString. \n",
- "mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)\n",
- "URL: http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text.html#v:mapAccumL\n",
- "O(n) Like a combination of map and foldl'. Applies a function to each element of a Text, passing an accumulating parameter from left to right, and returns a final Text. Performs replacement on invalid scalar values. \n",
- "mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)\n",
- "URL: http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text.html#v:mapAccumR\n",
- "The mapAccumR function behaves like a combination of map and a strict foldr; it applies a function to each element of a Text, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new Text. Performs replacement on invalid scalar values. \n",
- "execRWS :: RWS r w s a -> r -> s -> (s, w)\n",
- "URL: http://hackage.haskell.org/packages/archive/transformers/latest/doc/html/Control-Monad-Trans-RWS-Lazy.html#v:execRWS\n",
- "Evaluate a computation with the given initial state and environment, returning the final state and output, discarding the final value. \n",
- "breakSubstring :: ByteString -> ByteString -> (ByteString, ByteString)\n",
- "URL: http://hackage.haskell.org/packages/archive/bytestring/latest/doc/html/Data-ByteString.html#v:breakSubstring\n",
- "otherwise -> Just (length x) \n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/base/docs/GHC-List.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
"\n",
- "For example, to tokenise a string, dropping delimiters:\n",
+ "
\n",
+ "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
+ "
\n",
"\n",
- "> tokenise x y = h (:) if null t then [] else tokenise x (drop (length x) t)\n",
- "> \n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded:\n",
"\n",
- "To skip to the first occurence of a string:\n",
+ "
\n",
+ "zip [1] ['a', 'b'] = [(1, 'a')]\n",
+ "zip [1, 2] ['a'] = [(1, 'a')]\n",
+ "
\n",
"\n",
- "> snd (breakSubstring x y)\n",
+ "
zip is right-lazy:\n",
"\n",
- "To take the parts of a string before a delimiter:\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "zip _|_ [] = _|_\n",
+ "
\n",
"\n",
- "> fst (breakSubstring x y) \n",
- "breakOn :: Text -> Text -> (Text, Text)\n",
- "URL: http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text.html#v:breakOn\n",
- "O(n+m) Find the first instance of needle (which must be non-null) in haystack. The first element of the returned tuple is the prefix of haystack before needle is matched. The second is the remainder of haystack, starting with the match.\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/base/docs/GHC-OldList.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
"\n",
- "Examples:\n",
+ "
\n",
+ "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
+ "
\n",
"\n",
- "> breakOn \"::\" \"a::b::c\" ==> (\"a\", \"::b::c\")\n",
- "> breakOn \"/\" \"foobar\" ==> (\"foobar\", \"\")\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded:\n",
"\n",
- "Laws:\n",
+ "
\n",
+ "zip [1] ['a', 'b'] = [(1, 'a')]\n",
+ "zip [1, 2] ['a'] = [(1, 'a')]\n",
+ "
\n",
"\n",
- "> append prefix match == haystack\n",
- "> \n",
+ "
zip is right-lazy:\n",
"\n",
- "If you need to break a string by a substring repeatedly (e.g. you want to break on every instance of a substring), use breakOnAll instead, as it has lower startup overhead.\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "zip _|_ [] = _|_\n",
+ "
\n",
"\n",
- "In (unlikely) bad cases, this function's time complexity degrades towards O(n*m)."
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/hspec/docs/Test-Hspec-Discover.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/Cabal/docs/Distribution-Compat-Prelude-Internal.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zipExact :: Partial => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/safe/docs/Safe-Exact.html#v:zipExact\n",
+ "
\n",
+ "zipExact xs ys =\n",
+ "| length xs == length ys = zip xs ys\n",
+ "| otherwise = error \"some message\"\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/base-compat/docs/Prelude-Compat.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/protolude/docs/Protolude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/numeric-prelude/docs/NumericPrelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/numeric-prelude/docs/NumericPrelude-Base.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/rio/docs/RIO.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/rio/docs/RIO-List.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/fay-base/docs/Prelude.html#v:zip\n",
+ "\n",
+ "(+*+) :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/universe-base/docs/Data-Universe-Helpers.html#v:-43--42--43-\n",
+ "Slightly unfair 2-way Cartesian product: given two (possibly infinite)\n",
+ "lists, produce a single list such that whenever
v and\n",
+ "
w have finite indices in the input lists,
(v,w) has\n",
+ "finite index in the output list. Lower indices occur as the\n",
+ "
fst part of the tuple more frequently, but not exponentially\n",
+ "so.\n",
+ "\n",
+ "unfairCartesianProduct :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/universe-base/docs/Data-Universe-Helpers.html#v:unfairCartesianProduct\n",
+ "Very unfair 2-way Cartesian product: same guarantee as the slightly\n",
+ "unfair one, except that lower indices may occur as the
fst\n",
+ "part of the tuple exponentially more frequently. This mainly exists as\n",
+ "a specification to test against.\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/llvm-hs-pure/docs/LLVM-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/universum/docs/Universum-List-Reexport.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/haxl/docs/Haxl-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/prelude-compat/docs/Data-List2010.html#v:zip\n",
+ "\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/prelude-compat/docs/Prelude2010.html#v:zip\n",
+ "\n",
+ "zip :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/EdisonAPI/docs/Data-Edison-Seq-ListSeq.html#v:zip\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/intro/docs/Intro.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/yesod-paginator/docs/Yesod-Paginator-Prelude.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/hledger-web/docs/Hledger-Web-Import.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zip :: () => [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/relude/docs/Relude-List-Reexport.html#v:zip\n",
+ "
zip takes two lists and returns a list of corresponding pairs.\n",
+ "If one input list is short, excess elements of the longer list are\n",
+ "discarded.\n",
+ "\n",
+ "
zip is right-lazy:\n",
+ "\n",
+ "
\n",
+ "zip [] _|_ = []\n",
+ "
\n",
+ "\n",
+ "zipLazy :: [a] -> [b] -> [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/ghc/docs/Util.html#v:zipLazy\n",
+ "
zipLazy is a kind of
zip that is lazy in the second list\n",
+ "(observe the ~)\n",
+ "\n",
+ "concurrently :: MonadBaseControl IO m => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/lifted-async/docs/Control-Concurrent-Async-Lifted.html#v:concurrently\n",
+ "Generalized version of
concurrently.\n",
+ "\n",
+ "concurrently :: forall m a b . (MonadBaseControl IO m, Forall (Pure m)) => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/lifted-async/docs/Control-Concurrent-Async-Lifted-Safe.html#v:concurrently\n",
+ "Generalized version of
concurrently.\n",
+ "\n",
+ "pairADefault :: Applicative f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/invertible/docs/Control-Invertible-Monoidal.html#v:pairADefault\n",
+ "Default '>*< implementation for non-invertible\n",
+ "
Applicatives.\n",
+ "\n",
+ "zip :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b)\n",
+ "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Generic.html#v:zip\n",
+ "
O(min(m,n)) Zip two vectors\n",
+ "\n",
+ "pair :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b)\n",
+ "URL: https://hackage.haskell.org/package/statistics/docs/Statistics-Sample.html#v:pair\n",
+ "Pair two samples. It's like
zip but requires that both samples\n",
+ "have equal size.\n",
+ "\n",
+ "zip :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b)\n",
+ "URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector.html#v:zip\n",
+ "
O(min(m,n)) Zip two vectors\n",
+ "\n",
+ "concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/unliftio/docs/UnliftIO-Async.html#v:concurrently\n",
+ "Unlifted
concurrently.\n",
+ "\n",
+ "concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/yesod-websockets/docs/Yesod-WebSockets.html#v:concurrently\n",
+ "Unlifted
concurrently.\n",
+ "\n",
+ "zip :: Sequence s => s a -> s b -> s (a, b)\n",
+ "URL: https://hackage.haskell.org/package/EdisonAPI/docs/Data-Edison-Seq.html#v:zip\n",
+ "Combine two sequences into a sequence of pairs. If the sequences are\n",
+ "different lengths, the excess elements of the longer sequence is\n",
+ "discarded.\n",
+ "\n",
+ "
\n",
+ "zip <x0,...,xn-1> <y0,...,ym-1> = <(x0,y0),...,(xj-1,yj-1)>\n",
+ "where j = min {n,m}\n",
+ "\n",
+ "\n",
+ "
Axioms:\n",
+ "\n",
+ "
\n",
+ "\n",
+ "This function is always
unambiguous.\n",
+ "\n",
+ "Default running time:
O( min( n1, n2 ) )\n",
+ "\n",
+ "zipUsingLview :: Sequence s => s a -> s b -> s (a, b)\n",
+ "URL: https://hackage.haskell.org/package/EdisonCore/docs/Data-Edison-Seq-Defaults.html#v:zipUsingLview\n",
+ "\n",
+ "zipUsingLists :: Sequence s => s a -> s b -> s (a, b)\n",
+ "URL: https://hackage.haskell.org/package/EdisonCore/docs/Data-Edison-Seq-Defaults.html#v:zipUsingLists\n",
+ "\n",
+ "concurrently :: MonadConc m => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/concurrency/docs/Control-Concurrent-Classy-Async.html#v:concurrently\n",
+ "Run two
MonadConc actions concurrently, and return both\n",
+ "results. If either action throws an exception at any time, then the\n",
+ "other action is
cancelled, and the exception is re-thrown by\n",
+ "
concurrently.\n",
+ "\n",
+ "
\n",
+ "concurrently left right =\n",
+ "withAsync left $ \\a ->\n",
+ "withAsync right $ \\b ->\n",
+ "waitBoth a b\n",
+ "
\n",
+ "\n",
+ "mzipRep :: Representable f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/adjunctions/docs/Data-Functor-Rep.html#v:mzipRep\n",
+ "\n",
+ "box :: Graph g => g a -> g b -> g (a, b)\n",
+ "URL: https://hackage.haskell.org/package/algebraic-graphs/docs/Algebra-Graph-HigherKinded-Class.html#v:box\n",
+ "Compute the
Cartesian product of graphs. Complexity:
O(s1 *\n",
+ "s2) time, memory and size, where
s1 and
s2 are the\n",
+ "sizes of the given graphs.\n",
+ "\n",
+ "
\n",
+ "box (path [0,1]) (path \"ab\") == edges [ ((0,'a'), (0,'b'))\n",
+ ", ((0,'a'), (1,'a'))\n",
+ ", ((0,'b'), (1,'b'))\n",
+ ", ((1,'a'), (1,'b')) ]\n",
+ "
\n",
+ "\n",
+ "Up to an isomorphism between the resulting vertex types, this\n",
+ "operation is
commutative,
associative,\n",
+ "
distributes over
overlay, has singleton graphs as\n",
+ "
identities and
empty as the
annihilating zero.\n",
+ "Below
~~ stands for the equality up to an isomorphism, e.g.\n",
+ "
(x, ()) ~~ x.\n",
+ "\n",
+ "
\n",
+ "box x y ~~ box y x\n",
+ "box x (box y z) ~~ box (box x y) z\n",
+ "box x (overlay y z) == overlay (box x y) (box x z)\n",
+ "box x (vertex ()) ~~ x\n",
+ "box x empty ~~ empty\n",
+ "vertexCount (box x y) == vertexCount x * vertexCount y\n",
+ "edgeCount (box x y) <= vertexCount x * edgeCount y + edgeCount x * vertexCount y\n",
+ "
\n",
+ "\n",
+ "divided :: Divisible f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/contravariant/docs/Data-Functor-Contravariant-Divisible.html#v:divided\n",
+ "
\n",
+ "divided = divide id\n",
+ "
\n",
+ "\n",
+ "(>*<) :: Divisible f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/dhall/docs/Dhall.html#v:-62--42--60-\n",
+ "The
RecordInputType divisible (contravariant) functor allows\n",
+ "you to build an
InputType injector for a Dhall record.\n",
+ "\n",
+ "For example, let's take the following Haskell data type:\n",
+ "\n",
+ "
\n",
+ "data Project = Project\n",
+ "{ projectName :: Text\n",
+ ", projectDescription :: Text\n",
+ ", projectStars :: Natural\n",
+ "}\n",
+ "\n",
+ "\n",
+ "And assume that we have the following Dhall record that we would like\n",
+ "to parse as a
Project:\n",
+ "\n",
+ "
\n",
+ "{ name =\n",
+ "\"dhall-haskell\"\n",
+ ", description =\n",
+ "\"A configuration language guaranteed to terminate\"\n",
+ ", stars =\n",
+ "289\n",
+ "}\n",
+ "\n",
+ "\n",
+ "Our injector has type
InputType Project, but we can't\n",
+ "build that out of any smaller injectors, as
InputTypes cannot\n",
+ "be combined (they are only
Contravariants). However, we can use\n",
+ "an
InputRecordType to build an
InputType for\n",
+ "
Project:\n",
+ "\n",
+ "
\n",
+ "injectProject :: InputType Project\n",
+ "injectProject =\n",
+ "inputRecord\n",
+ "( adapt >$< inputFieldWith \"name\" inject\n",
+ ">*< inputFieldWith \"description\" inject\n",
+ ">*< inputFieldWith \"stars\" inject\n",
+ ")\n",
+ "where\n",
+ "adapt (Project{..}) = (projectName, (projectDescription, projectStars))\n",
+ "\n",
+ "\n",
+ "Or, since we are simply using the
Inject instance to inject\n",
+ "each field, we could write\n",
+ "\n",
+ "
\n",
+ "injectProject :: InputType Project\n",
+ "injectProject =\n",
+ "inputRecord\n",
+ "( adapt >$< inputField \"name\"\n",
+ ">*< inputField \"description\"\n",
+ ">*< inputField \"stars\"\n",
+ ")\n",
+ "where\n",
+ "adapt (Project{..}) = (projectName, (projectDescription, projectStars))\n",
+ "\n",
+ "\n",
+ "Infix
divided\n",
+ "\n",
+ "divided :: Divisible f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:divided\n",
+ "
\n",
+ "divided = divide id\n",
+ "
\n",
+ "\n",
+ "(>*<) :: Divisible f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:-62--42--60-\n",
+ "An alias to
divided.\n",
+ "\n",
+ "(>*<) :: Divisible f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/contravariant-extras/docs/Contravariant-Extras.html#v:-62--42--60-\n",
+ "An alias to
divided.\n",
+ "\n",
+ "contrazip2 :: Divisible f => f a1 -> f a2 -> f (a1, a2)\n",
+ "URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:contrazip2\n",
+ "\n",
+ "contrazip2 :: forall f a1 a2 . Divisible f => f a1 -> f a2 -> f (a1, a2)\n",
+ "URL: https://hackage.haskell.org/package/contravariant-extras/docs/Contravariant-Extras-Contrazip.html#v:contrazip2\n",
+ "\n",
+ "pair :: Sized f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/size-based/docs/Control-Sized.html#v:pair\n",
+ "Default:
pair a b = (,) $ a * b.\n",
+ "\n",
+ "(>*<) :: Monoidal f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/bytestring/docs/Data-ByteString-Builder-Prim.html#v:-62--42--60-\n",
+ "A pairing/concatenation operator for builder primitives, both bounded\n",
+ "and fixed size.\n",
+ "\n",
+ "For example,\n",
+ "\n",
+ "
\n",
+ "toLazyByteString (primFixed (char7 >*< char7) ('x','y')) = \"xy\"\n",
+ "\n",
+ "\n",
+ "We can combine multiple primitives using
>*< multiple\n",
+ "times.\n",
+ "\n",
+ "
\n",
+ "toLazyByteString (primFixed (char7 >*< char7 >*< char7) ('x',('y','z'))) = \"xyz\"\n",
+ "\n",
+ "\n",
+ "(>*<) :: Monoidal f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/invertible/docs/Control-Invertible-Monoidal.html#v:-62--42--60-\n",
+ "Merge two functors into a tuple, analogous to
liftA2\n",
+ "(,). (Sometimes known as
**.)\n",
+ "\n",
+ "zip :: List l => l a -> l b -> l (a, b)\n",
+ "URL: https://hackage.haskell.org/package/List/docs/Data-List-Class.html#v:zip\n",
+ "\n",
+ "zip :: Zip f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/classy-prelude/docs/ClassyPrelude.html#v:zip\n",
+ "\n",
+ "zip :: (Zip f) => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/non-empty/docs/Data-NonEmpty-Class.html#v:zip\n",
+ "\n",
+ "zip :: Zip f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/keys/docs/Data-Key.html#v:zip\n",
+ "\n",
+ "zip :: Zip f => f a -> f b -> f (a, b)\n",
+ "URL: https://hackage.haskell.org/package/chunked-data/docs/Data-ChunkedZip.html#v:zip\n",
+ "\n",
+ "mzip :: MonadZip m => m a -> m b -> m (a, b)\n",
+ "URL: https://hackage.haskell.org/package/base/docs/Control-Monad-Zip.html#v:mzip\n",
+ "\n",
+ "projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)\n",
+ "URL: https://hackage.haskell.org/package/relational-query/docs/Database-Relational-Arrow.html#v:projectZip\n",
+ "Zipping projections.\n",
+ "\n",
+ "(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)\n",
+ "URL: https://hackage.haskell.org/package/relational-query/docs/Database-Relational-Arrow.html#v:-62--60-\n",
+ "Binary operator the same as
projectZip.\n",
+ "\n",
+ "projectZip :: ProductIsoApplicative p => p a -> p b -> p (a, b)\n",
+ "URL: https://hackage.haskell.org/package/relational-query/docs/Database-Relational-Projectable.html#v:projectZip\n",
+ "Zipping projections.\n",
+ "\n",
+ "(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)\n",
+ "URL: https://hackage.haskell.org/package/relational-query/docs/Database-Relational-Projectable.html#v:-62--60-\n",
+ "Binary operator the same as
projectZip.\n",
+ "\n",
+ "(><) :: ProductIsoApplicative p => p a -> p b -> p (a, b)\n",
+ "URL: https://hackage.haskell.org/package/relational-record/docs/Database-Relational-Documentation.html#v:-62--60-\n",
+ "Binary operator the same as
projectZip.\n",
+ "\n",
+ "biunfold :: (Biunfoldable t, Unfolder f) => f a -> f b -> f (t a b)\n",
+ "URL: https://hackage.haskell.org/package/unfoldable/docs/Data-Biunfoldable.html#v:biunfold\n",
+ "Given a way to generate elements, return a way to generate structures\n",
+ "containing those elements.\n",
+ "\n",
+ "biunfoldBF :: (Biunfoldable t, Unfolder f) => f a -> f b -> f (t a b)\n",
+ "URL: https://hackage.haskell.org/package/unfoldable/docs/Data-Biunfoldable.html#v:biunfoldBF\n",
+ "Breadth-first unfold, which orders the result by the number of\n",
+ "
choose calls.\n",
+ "\n",
+ "deserializeWith2 :: (Serial2 f, MonadGet m) => m a -> m b -> m (f a b)\n",
+ "URL: https://hackage.haskell.org/package/bytes/docs/Data-Bytes-Serial.html#v:deserializeWith2\n",
+ "\n",
+ "biunfoldRestrict :: (BiunfoldableR predA predB t, predA a, predB b, Unfolder f) => f a -> f b -> f (t a b)\n",
+ "URL: https://hackage.haskell.org/package/unfoldable-restricted/docs/Data-Unfoldable-Restricted.html#v:biunfoldRestrict\n",
+ "\n",
+ "biunfoldRestrictBF :: (BiunfoldableR p q t, Unfolder f, p a, q b) => f a -> f b -> f (t a b)\n",
+ "URL: https://hackage.haskell.org/package/unfoldable-restricted/docs/Data-Unfoldable-Restricted.html#v:biunfoldRestrictBF\n",
+ "\n",
+ "mesh :: Graph g => [a] -> [b] -> g (a, b)\n",
+ "URL: https://hackage.haskell.org/package/algebraic-graphs/docs/Algebra-Graph-HigherKinded-Class.html#v:mesh\n",
+ "Construct a
mesh graph from two lists of vertices. Complexity:\n",
+ "
O(L1 * L2) time, memory and size, where
L1 and
L2\n",
+ "are the lengths of the given lists.\n",
+ "\n",
+ "
\n",
+ "mesh xs [] == empty\n",
+ "mesh [] ys == empty\n",
+ "mesh [x] [y] == vertex (x, y)\n",
+ "mesh xs ys == box (path xs) (path ys)\n",
+ "mesh [1..3] \"ab\" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(2,'b')), ((2,'a'),(2,'b'))\n",
+ ", ((2,'a'),(3,'a')), ((2,'b'),(3,'b')), ((3,'a'),(3,'b')) ]\n",
+ "
\n",
+ "\n",
+ "torus :: Graph g => [a] -> [b] -> g (a, b)\n",
+ "URL: https://hackage.haskell.org/package/algebraic-graphs/docs/Algebra-Graph-HigherKinded-Class.html#v:torus\n",
+ "Construct a
torus graph from two lists of vertices. Complexity:\n",
+ "
O(L1 * L2) time, memory and size, where
L1 and
L2\n",
+ "are the lengths of the given lists.\n",
+ "\n",
+ "
\n",
+ "torus xs [] == empty\n",
+ "torus [] ys == empty\n",
+ "torus [x] [y] == edge (x,y) (x,y)\n",
+ "torus xs ys == box (circuit xs) (circuit ys)\n",
+ "torus [1,2] \"ab\" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(1,'a')), ((1,'b'),(2,'b'))\n",
+ ", ((2,'a'),(1,'a')), ((2,'a'),(2,'b')), ((2,'b'),(1,'b')), ((2,'b'),(2,'a')) ]\n",
+ "
\n",
+ "\n",
+ "zipExactMay :: [a] -> [b] -> Maybe [(a, b)]\n",
+ "URL: https://hackage.haskell.org/package/safe/docs/Safe-Exact.html#v:zipExactMay"
]
},
"metadata": {},
@@ -2236,10 +3202,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"If you need a refresher on all of the options, you can just use `:help`:"
]
@@ -2247,11 +3210,7 @@
{
"cell_type": "code",
"execution_count": 26,
- "metadata": {
- "collapsed": false,
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"outputs": [
{
"data": {
@@ -2288,10 +3247,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"All of the code you normally put into IHaskell is (like in GHCi) interpreted. However, sometimes you've perfected a function, and now need it to run faster. In that case, you can go ahead and define a module in a single cell. As long as your module has a module header along the lines of `module Name where`, IHaskell will recognize it as a module. It will create the file `A/B.hs`, compile it, and load it. "
]
@@ -2299,11 +3255,7 @@
{
"cell_type": "code",
"execution_count": 27,
- "metadata": {
- "collapsed": false,
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"outputs": [],
"source": [
"-- If your code isn't running fast enough, you can just put it into a module.\n",
@@ -2316,10 +3268,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"Note that the module is by default imported unqualified, as though you had typed `import A.B`."
]
@@ -2327,11 +3276,7 @@
{
"cell_type": "code",
"execution_count": 28,
- "metadata": {
- "collapsed": false,
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"outputs": [
{
"data": {
@@ -2360,10 +3305,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"Note that since a new module is imported, all previous bound identifiers are now unbound. For instance, we no longer have access to the `f` function from before:"
]
@@ -2371,11 +3313,7 @@
{
"cell_type": "code",
"execution_count": 29,
- "metadata": {
- "collapsed": false,
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"outputs": [
{
"data": {
@@ -2477,10 +3415,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"However, if you re-import this module with another import statement, the original implicit import goes away."
]
@@ -2488,11 +3423,7 @@
{
"cell_type": "code",
"execution_count": 30,
- "metadata": {
- "collapsed": false,
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"outputs": [
{
"data": {
@@ -2522,10 +3453,7 @@
},
{
"cell_type": "markdown",
- "metadata": {
- "deletable": true,
- "editable": true
- },
+ "metadata": {},
"source": [
"Thanks!\n",
"---\n",
@@ -2549,7 +3477,8 @@
"codemirror_mode": "ihaskell",
"file_extension": ".hs",
"name": "haskell",
- "version": "8.0.2"
+ "pygments_lexer": "Haskell",
+ "version": "8.4.3"
},
"latex_envs": {
"bibliofile": "biblio.bib",
@@ -2570,5 +3499,5 @@
}
},
"nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
}
diff --git a/src/IHaskell/Eval/Hoogle.hs b/src/IHaskell/Eval/Hoogle.hs
index bb326999..b946b324 100644
--- a/src/IHaskell/Eval/Hoogle.hs
+++ b/src/IHaskell/Eval/Hoogle.hs
@@ -1,24 +1,31 @@
-{-# LANGUAGE NoImplicitPrelude, FlexibleInstances, OverloadedStrings #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE OverloadedStrings #-}
module IHaskell.Eval.Hoogle (
search,
document,
render,
OutputFormat(..),
- HoogleResult,
+ HoogleResult(..),
+ HoogleResponse(..),
+ parseResponse,
) where
+import qualified Data.ByteString.Char8 as CBS
+import qualified Data.ByteString.Lazy as LBS
+import Data.Either (either)
import IHaskellPrelude
-import qualified Data.ByteString.Lazy as LBS
-import qualified Data.ByteString.Char8 as CBS
+import Data.Aeson
+import Data.Char (isAlphaNum, isAscii)
+import qualified Data.List as List
+import qualified Data.Text as T
+import Data.Vector (toList)
import Network.HTTP.Client
import Network.HTTP.Client.TLS
-import Data.Aeson
-import qualified Data.List as List
-import Data.Char (isAscii, isAlphaNum)
-import StringUtils (split, strip, replace)
+import StringUtils (replace, split, strip)
-- | Types of formats to render output to.
data OutputFormat = Plain -- ^ Render to plain text.
@@ -35,17 +42,19 @@ data HoogleResult = SearchResult HoogleResponse
data HoogleResponseList = HoogleResponseList [HoogleResponse]
instance FromJSON HoogleResponseList where
- parseJSON (Object obj) = do
- results <- obj .: "results"
- HoogleResponseList <$> mapM parseJSON results
+ parseJSON (Array arr) =
+ HoogleResponseList <$> mapM parseJSON (toList arr)
- parseJSON _ = fail "Expected object with 'results' field."
+ parseJSON _ = fail "Expected array."
instance FromJSON HoogleResponse where
parseJSON (Object obj) =
- HoogleResponse <$> obj .: "location" <*> obj .: "self" <*> obj .: "docs"
+ HoogleResponse
+ <$> obj .: "url"
+ <*> (removeMarkup <$> obj .: "item")
+ <*> obj .: "docs"
- parseJSON _ = fail "Expected object with fields: location, self, docs"
+ parseJSON _ = fail "Expected object with fields: url, item, docs"
-- | Query Hoogle for the given string. This searches Hoogle using the internet. It returns either
-- an error message or the successful JSON result.
@@ -59,7 +68,7 @@ query str = do
where
queryUrl :: String -> String
- queryUrl = printf "https://www.haskell.org/hoogle/?hoogle=%s&mode=json"
+ queryUrl = printf "http://hoogle.haskell.org/?hoogle=%s&mode=json"
-- | Copied from the HTTP package.
urlEncode :: String -> String
@@ -87,18 +96,16 @@ urlEncode (ch:t)
-- | Search for a query on Hoogle. Return all search results.
search :: String -> IO [HoogleResult]
-search string = do
- response <- query string
- return $
- case response of
- Left err -> [NoResult err]
- Right jsn ->
- case eitherDecode $ LBS.fromStrict $ CBS.pack jsn of
- Left err -> [NoResult err]
- Right results ->
- case map SearchResult $ (\(HoogleResponseList l) -> l) results of
- [] -> [NoResult "no matching identifiers found."]
- res -> res
+search string = either ((:[]) . NoResult) parseResponse <$> query string
+
+parseResponse :: String -> [HoogleResult]
+parseResponse jsn =
+ case eitherDecode $ LBS.fromStrict $ CBS.pack jsn of
+ Left err -> [NoResult err]
+ Right results ->
+ case map SearchResult $ (\(HoogleResponseList l) -> l) results of
+ [] -> [NoResult "no matching identifiers found."]
+ res -> res
-- | Look up an identifier on Hoogle. Return documentation for that identifier. If there are many
-- identifiers, include documentation for all of them.
@@ -118,13 +125,13 @@ document string = do
matches _ = False
toDocResult (SearchResult resp) = Just $ DocResult resp
- toDocResult (DocResult _) = Nothing
- toDocResult (NoResult _) = Nothing
+ toDocResult (DocResult _) = Nothing
+ toDocResult (NoResult _) = Nothing
-- | Render a Hoogle search result into an output format.
render :: OutputFormat -> HoogleResult -> String
render Plain = renderPlain
-render HTML = renderHtml
+render HTML = renderHtml
-- | Render a Hoogle result to plain text.
renderPlain :: HoogleResult -> String
@@ -181,6 +188,12 @@ renderSelf string loc
span "hoogle-class" (link loc $ extractNewtype string) ++
packageSub package
+ | "type" `isPrefixOf` string =
+ let package = extractPackageName loc
+ in nwt ++ " " ++
+ span "hoogle-class" (link loc $ extractType string) ++
+ packageSub package
+
| otherwise =
let [name, args] = split "::" string
package = extractPackageName loc
@@ -197,6 +210,7 @@ renderSelf string loc
extractClass = strip . replace "class" ""
extractData = strip . replace "data" ""
extractNewtype = strip . replace "newtype" ""
+ extractType = strip . replace "newtype" ""
pkg = span "hoogle-head" "package"
mdl = span "hoogle-head" "module"
cls = span "hoogle-head" "class"
@@ -223,21 +237,7 @@ renderSelf string loc
", " ++ mdl ++ " " ++ span "hoogle-module" modname ++ ")"
renderDocs :: String -> String
-renderDocs doc =
- let groups = List.groupBy bothAreCode $ lines doc
- nonull = filter (not . null . strip)
- bothAreCode s1 s2 =
- isPrefixOf ">" (strip s1) &&
- isPrefixOf ">" (strip s2)
- isCode xs =
- case xs of
- [] -> False
- (s:_) -> isPrefixOf ">" $ strip s
- makeBlock xs =
- if isCode xs
- then div' "hoogle-code" $ unlines $ nonull xs
- else div' "hoogle-text" $ unlines $ nonull xs
- in div' "hoogle-doc" $ unlines $ map makeBlock groups
+renderDocs doc = div' "hoogle-doc" doc
extractPackageName :: String -> Maybe String
extractPackageName lnk = do
@@ -259,3 +259,19 @@ span = printf "
%s"
link :: String -> String -> String
link = printf "
%s"
+
+-- | very explicit cleaning of the type signature in the hoogle 5 response,
+-- to remove html markup and escaped characters.
+removeMarkup :: String -> String
+removeMarkup s = T.unpack $ List.foldl (flip ($)) (T.pack s) replaceAll
+ where replacements :: [ (T.Text, T.Text) ]
+ replacements = [ ( "
", "" )
+ , ( "", "" )
+ , ( "<0>", "" )
+ , ( "", "" )
+ , ( ">", ">" )
+ , ( "<", "<" )
+ , ( "
", "")
+ , ( "", "")
+ ]
+ replaceAll = uncurry T.replace <$> replacements
diff --git a/src/tests/Hspec.hs b/src/tests/Hspec.hs
index 38b58169..eb708f3b 100644
--- a/src/tests/Hspec.hs
+++ b/src/tests/Hspec.hs
@@ -7,10 +7,12 @@ import Test.Hspec
import IHaskell.Test.Completion (testCompletions)
import IHaskell.Test.Parser (testParser)
import IHaskell.Test.Eval (testEval)
+import IHaskell.Test.Hoogle (testHoogle)
main :: IO ()
-main =
+main =
hspec $ do
testParser
testEval
testCompletions
+ testHoogle
diff --git a/src/tests/IHaskell/Test/Hoogle.hs b/src/tests/IHaskell/Test/Hoogle.hs
new file mode 100644
index 00000000..49227b52
--- /dev/null
+++ b/src/tests/IHaskell/Test/Hoogle.hs
@@ -0,0 +1,63 @@
+{-# LANGUAGE QuasiQuotes #-}
+
+module IHaskell.Test.Hoogle ( testHoogle ) where
+
+import Test.Hspec
+import Text.RawString.QQ
+
+import IHaskell.Eval.Hoogle
+-- import Data.Text (unpack)
+-- import qualified Data.Text.IO as T
+preludeFmapJson :: String
+preludeFmapJson = [r|
+[
+ {
+ "url": "https://hackage.haskell.org/package/base/docs/Prelude.html#v:fmap",
+ "module": {
+ "url": "https://hackage.haskell.org/package/base/docs/Prelude.html",
+ "name": "Prelude"
+ },
+ "package": {
+ "url": "https://hackage.haskell.org/package/base",
+ "name": "base"
+ },
+ "item": "
<0>fmap :: Functor f => (a -> b) -> f a -> f b",
+ "type": "",
+ "docs": ""
+ }
+]|]
+
+moduleJson :: String
+moduleJson = [r|
+[
+ {
+ "url": "https://hackage.haskell.org/package/universum/docs/Universum-Functor-Fmap.html",
+ "module": {},
+ "package": {
+ "url": "https://hackage.haskell.org/package/universum",
+ "name": "universum"
+ },
+ "item": "
module Universum.Functor.
<0>Fmap",
+ "type": "module",
+ "docs": "This module contains useful functions to work with
Functor type\nclass.\n"
+ }
+]|]
+
+testHoogle :: Spec
+testHoogle = describe "Hoogle Search" $ do
+ describe "fmap search result" $ do
+ let results = parseResponse preludeFmapJson :: [HoogleResult]
+ it "should find 1 results" $ do
+ length results `shouldBe` 1
+ let (SearchResult (HoogleResponse loc signature _docUrl)) = head results
+ it "should not contain html markup" $ do
+ loc `shouldBe` "https://hackage.haskell.org/package/base/docs/Prelude.html#v:fmap"
+ signature `shouldBe` "fmap :: Functor f => (a -> b) -> f a -> f b"
+ describe "module result" $ do
+ let results = parseResponse moduleJson :: [HoogleResult]
+ let (SearchResult (HoogleResponse _loc signature _docUrl)) = head results
+ it "should not contain html markup" $ do
+ signature `shouldBe` "module Universum.Functor.Fmap"
+ it "should be renderable" $ do
+ (render Plain $ head results) `shouldStartWith` "module Universum.Functor.Fmap"
+ (render HTML $ head results) `shouldStartWith` "
module"