mirrors/IHaskell
1
0
Fork 0
mirror of https://github.com/IHaskell/IHaskell.git synced 2025-04-18 12:26:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

notebooks/IHaskell.ipynb: update

Browse Source
This commit is contained in:
Vaibhav Sagar 2019-02-08 11:35:14 -05:00
parent c070adf882
commit c684300b7e
1 changed files with 117 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
notebooks/IHaskell.ipynb
View File

@ -2000,7 +2000,6 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/fay-base/docs/Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
@ -2054,6 +2053,16 @@
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/xmonad-contrib/docs/XMonad-Config-Prime.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/haxl/docs/Haxl-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
@ -2087,27 +2096,6 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/EdisonAPI/docs/Data-Edison-Seq-ListSeq.html#v:zip'><s0>zip</s0></a> &#x2237; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/mixed-types-num/docs/Numeric-MixedTypes-PreludeHiding.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
"\n",
"<pre>\n",
@ -2181,6 +2169,16 @@
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/distribution-opensuse/docs/OpenSuse-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/hledger-web/docs/Hledger-Web-Import.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
"\n",
"<pre>\n",
@ -2202,6 +2200,27 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/hsdev/docs/HsDev-Tools-Ghc-Prelude.html#v:zip'><s0>zip</s0></a> &#x2237; () &#x21D2; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
"\n",
"<pre>\n",
"zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
"</pre>\n",
"\n",
"If one input list is short, excess elements of the longer list are\n",
"discarded:\n",
"\n",
"<pre>\n",
"zip [1] ['a', 'b'] = [(1, 'a')]\n",
"zip [1, 2] ['a'] = [(1, 'a')]\n",
"</pre>\n",
"\n",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"zip _|_ [] = _|_\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/ghc/docs/Util.html#v:zipLazy'><s0>zipLazy</s0></a> &#x2237; [a] &#x2192; [b] &#x2192; [(a, b)]</span><div class='hoogle-doc'><a>zipLazy</a> is a kind of <a>zip</a> that is lazy in the second list\n",
"(observe the ~)\n",
"</div>\n",
@ -2220,28 +2239,6 @@
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/yesod-websockets/docs/Yesod-WebSockets.html#v:concurrently'><s0>concurrently</s0></a> &#x2237; MonadUnliftIO m &#x21D2; m a &#x2192; m b &#x2192; m (a, b)</span><div class='hoogle-doc'>Unlifted <a>concurrently</a>.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/EdisonAPI/docs/Data-Edison-Seq.html#v:zip'><s0>zip</s0></a> &#x2237; Sequence s &#x21D2; s a &#x2192; s b &#x2192; s (a, b)</span><div class='hoogle-doc'>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",
"<pre>\n",
"zip &lt;x0,...,xn-1&gt; &lt;y0,...,ym-1&gt; = &lt;(x0,y0),...,(xj-1,yj-1)&gt;\n",
"where j = min {n,m}\n",
"</pre>\n",
"\n",
"<i>Axioms:</i>\n",
"\n",
"<ul>\n",
"<li><pre>zip xs ys = zipWith (,) xs ys</pre></li>\n",
"</ul>\n",
"\n",
"This function is always <i>unambiguous</i>.\n",
"\n",
"Default running time: <tt>O( min( n1, n2 ) )</tt>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/EdisonCore/docs/Data-Edison-Seq-Defaults.html#v:zipUsingLview'><s0>zipUsingLview</s0></a> &#x2237; Sequence s &#x21D2; s a &#x2192; s b &#x2192; s (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/EdisonCore/docs/Data-Edison-Seq-Defaults.html#v:zipUsingLists'><s0>zipUsingLists</s0></a> &#x2237; Sequence s &#x21D2; s a &#x2192; s b &#x2192; s (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/adjunctions/docs/Data-Functor-Rep.html#v:mzipRep'><s0>mzipRep</s0></a> &#x2237; Representable f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/concurrency/docs/Control-Concurrent-Classy-Async.html#v:concurrently'><s0>concurrently</s0></a> &#x2237; MonadConc m &#x21D2; m a &#x2192; m b &#x2192; m (a, b)</span><div class='hoogle-doc'>Run two <tt>MonadConc</tt> actions concurrently, and return both\n",
"results. If either action throws an exception at any time, then the\n",
"other action is <a>cancel</a>led, and the exception is re-thrown by\n",
@ -2254,6 +2251,7 @@
"waitBoth a b\n",
"</pre>\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/adjunctions/docs/Data-Functor-Rep.html#v:mzipRep'><s0>mzipRep</s0></a> &#x2237; Representable f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/contravariant/docs/Data-Functor-Contravariant-Divisible.html#v:divided'><s0>divided</s0></a> &#x2237; Divisible f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'><pre>\n",
"<a>divided</a> = <a>divide</a> <a>id</a>\n",
"</pre>\n",
@ -2329,6 +2327,9 @@
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:contrazip2'><s0>contrazip2</s0></a> &#x2237; Divisible f &#x21D2; f a1 &#x2192; f a2 &#x2192; f (a1, a2)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/contravariant-extras/docs/Contravariant-Extras-Contrazip.html#v:contrazip2'><s0>contrazip2</s0></a> &#x2237; &#x2200; f a1 a2 . Divisible f &#x21D2; f a1 &#x2192; f a2 &#x2192; f (a1, a2)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/List/docs/Data-List-Class.html#v:zip'><s0>zip</s0></a> &#x2237; List l &#x21D2; l a &#x2192; l b &#x2192; l (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/size-based/docs/Control-Sized.html#v:pair'><s0>pair</s0></a> &#x2237; Sized f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'>Default: <tt>pair a b = (,) <a>$</a> a <a>*</a> b</tt>.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/vector/docs/Data-Vector-Generic.html#v:zip'><s0>zip</s0></a> &#x2237; (Vector v a, Vector v b, Vector v (a, b)) &#x21D2; v a &#x2192; v b &#x2192; v (a, b)</span><div class='hoogle-doc'><i>O(min(m,n))</i> Zip two vectors\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/statistics/docs/Statistics-Sample.html#v:pair'><s0>pair</s0></a> &#x2237; (Vector v a, Vector v b, Vector v (a, b)) &#x21D2; v a &#x2192; v b &#x2192; v (a, b)</span><div class='hoogle-doc'>Pair two samples. It's like <a>zip</a> but requires that both samples\n",
@ -2336,8 +2337,10 @@
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/rio/docs/RIO-Vector.html#v:zip'><s0>zip</s0></a> &#x2237; (Vector v a, Vector v b, Vector v (a, b)) &#x21D2; v a &#x2192; v b &#x2192; v (a, b)</span><div class='hoogle-doc'><i>O(min(m,n))</i> Zip two vectors\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/size-based/docs/Control-Sized.html#v:pair'><s0>pair</s0></a> &#x2237; Sized f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'>Default: <tt>pair a b = (,) <a>$</a> a <a>*</a> b</tt>.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/classy-prelude/docs/ClassyPrelude.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/non-empty/docs/Data-NonEmpty-Class.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/keys/docs/Data-Key.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/chunked-data/docs/Data-ChunkedZip.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/bytestring/docs/Data-ByteString-Builder-Prim.html#v:-62--42--60-'>(<s0>>*<</s0>)</a> &#x2237; Monoidal f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'>A pairing/concatenation operator for builder primitives, both bounded\n",
"and fixed size.\n",
"\n",
@ -2357,11 +2360,6 @@
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/invertible/docs/Control-Invertible-Monoidal.html#v:-62--42--60-'>(<s0>>*<</s0>)</a> &#x2237; Monoidal f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'>Merge two functors into a tuple, analogous to <tt><a>liftA2</a>\n",
"(,)</tt>. (Sometimes known as <tt>**</tt>.)\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/List/docs/Data-List-Class.html#v:zip'><s0>zip</s0></a> &#x2237; List l &#x21D2; l a &#x2192; l b &#x2192; l (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/classy-prelude/docs/ClassyPrelude.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/non-empty/docs/Data-NonEmpty-Class.html#v:zip'><s0>zip</s0></a> &#x2237; (Zip f) &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/keys/docs/Data-Key.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/chunked-data/docs/Data-ChunkedZip.html#v:zip'><s0>zip</s0></a> &#x2237; Zip f &#x21D2; f a &#x2192; f b &#x2192; f (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/base/docs/Control-Monad-Zip.html#v:mzip'><s0>mzip</s0></a> &#x2237; MonadZip m &#x21D2; m a &#x2192; m b &#x2192; m (a, b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/relational-query/docs/Database-Relational-Arrow.html#v:projectZip'><s0>projectZip</s0></a> &#x2237; ProductIsoApplicative p &#x21D2; p a &#x2192; p b &#x2192; p (a, b)</span><div class='hoogle-doc'>Zipping projections.\n",
"</div>\n",
@ -2373,15 +2371,7 @@
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/relational-record/docs/Database-Relational-Documentation.html#v:-62--60-'>(<s0>><</s0>)</a> &#x2237; ProductIsoApplicative p &#x21D2; p a &#x2192; p b &#x2192; p (a, b)</span><div class='hoogle-doc'>Binary operator the same as <a>projectZip</a>.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/unfoldable/docs/Data-Biunfoldable.html#v:biunfold'><s0>biunfold</s0></a> &#x2237; (Biunfoldable t, Unfolder f) &#x21D2; f a &#x2192; f b &#x2192; f (t a b)</span><div class='hoogle-doc'>Given a way to generate elements, return a way to generate structures\n",
"containing those elements.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/unfoldable/docs/Data-Biunfoldable.html#v:biunfoldBF'><s0>biunfoldBF</s0></a> &#x2237; (Biunfoldable t, Unfolder f) &#x21D2; f a &#x2192; f b &#x2192; f (t a b)</span><div class='hoogle-doc'>Breadth-first unfold, which orders the result by the number of\n",
"<a>choose</a> calls.\n",
"</div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/bytes/docs/Data-Bytes-Serial.html#v:deserializeWith2'><s0>deserializeWith2</s0></a> &#x2237; (Serial2 f, MonadGet m) &#x21D2; m a &#x2192; m b &#x2192; m (f a b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/unfoldable-restricted/docs/Data-Unfoldable-Restricted.html#v:biunfoldRestrict'><s0>biunfoldRestrict</s0></a> &#x2237; (BiunfoldableR predA predB t, predA a, predB b, Unfolder f) &#x21D2; f a &#x2192; f b &#x2192; f (t a b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/unfoldable-restricted/docs/Data-Unfoldable-Restricted.html#v:biunfoldRestrictBF'><s0>biunfoldRestrictBF</s0></a> &#x2237; (BiunfoldableR p q t, Unfolder f, p a, q b) &#x21D2; f a &#x2192; f b &#x2192; f (t a b)</span><div class='hoogle-doc'></div>\n",
"<span class='hoogle-name'><a target='_blank' href='https://hackage.haskell.org/package/algebraic-graphs/docs/Algebra-Graph-HigherKinded-Class.html#v:mesh'><s0>mesh</s0></a> &#x2237; Graph g &#x21D2; [a] &#x2192; [b] &#x2192; g (a, b)</span><div class='hoogle-doc'>Construct a <i>mesh graph</i> from two lists of vertices. Complexity:\n",
"<i>O(L1 * L2)</i> time, memory and size, where <i>L1</i> and <i>L2</i>\n",
"are the lengths of the given lists.\n",
@ -2651,9 +2641,6 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/fay-base/docs/Prelude.html#v:zip\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:zip\n",
"<a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
@ -2718,6 +2705,18 @@
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/xmonad-contrib/docs/XMonad-Config-Prime.html#v:zip\n",
"<a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/haxl/docs/Haxl-Prelude.html#v:zip\n",
"<a>zip</a> 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",
@ -2758,33 +2757,6 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/EdisonAPI/docs/Data-Edison-Seq-ListSeq.html#v:zip\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip\n",
"<a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/LambdaHack/docs/Game-LambdaHack-Common-Prelude.html#v:zip\n",
"<a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/mixed-types-num/docs/Numeric-MixedTypes-PreludeHiding.html#v:zip\n",
"<a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
@ -2867,6 +2839,18 @@
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/distribution-opensuse/docs/OpenSuse-Prelude.html#v:zip\n",
"<a>zip</a> 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",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/hledger-web/docs/Hledger-Web-Import.html#v:zip\n",
"<a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
"\n",
@ -2889,6 +2873,29 @@
"zip _|_ [] = _|_\n",
"</pre>\n",
"\n",
"<s0>zip</s0> :: () => [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/hsdev/docs/HsDev-Tools-Ghc-Prelude.html#v:zip\n",
"<a>zip</a> takes two lists and returns a list of corresponding pairs.\n",
"\n",
"<pre>\n",
"zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
"</pre>\n",
"\n",
"If one input list is short, excess elements of the longer list are\n",
"discarded:\n",
"\n",
"<pre>\n",
"zip [1] ['a', 'b'] = [(1, 'a')]\n",
"zip [1, 2] ['a'] = [(1, 'a')]\n",
"</pre>\n",
"\n",
"<a>zip</a> is right-lazy:\n",
"\n",
"<pre>\n",
"zip [] _|_ = []\n",
"zip _|_ [] = _|_\n",
"</pre>\n",
"\n",
"<s0>zipLazy</s0> :: [a] -> [b] -> [(a, b)]\n",
"URL: https://hackage.haskell.org/package/ghc/docs/Util.html#v:zipLazy\n",
"<a>zipLazy</a> is a kind of <a>zip</a> that is lazy in the second list\n",
@ -2923,36 +2930,6 @@
"URL: https://hackage.haskell.org/package/yesod-websockets/docs/Yesod-WebSockets.html#v:concurrently\n",
"Unlifted <a>concurrently</a>.\n",
"\n",
"<s0>zip</s0> :: 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",
"<pre>\n",
"zip &lt;x0,...,xn-1&gt; &lt;y0,...,ym-1&gt; = &lt;(x0,y0),...,(xj-1,yj-1)&gt;\n",
"where j = min {n,m}\n",
"</pre>\n",
"\n",
"<i>Axioms:</i>\n",
"\n",
"<ul>\n",
"<li><pre>zip xs ys = zipWith (,) xs ys</pre></li>\n",
"</ul>\n",
"\n",
"This function is always <i>unambiguous</i>.\n",
"\n",
"Default running time: <tt>O( min( n1, n2 ) )</tt>\n",
"\n",
"<s0>zipUsingLview</s0> :: 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",
"<s0>zipUsingLists</s0> :: 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",
"<s0>mzipRep</s0> :: 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",
"<s0>concurrently</s0> :: 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 <tt>MonadConc</tt> actions concurrently, and return both\n",
@ -2967,6 +2944,9 @@
"waitBoth a b\n",
"</pre>\n",
"\n",
"<s0>mzipRep</s0> :: 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",
"<s0>divided</s0> :: 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",
"<pre>\n",
@ -3056,6 +3036,13 @@
"<s0>contrazip2</s0> :: 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",
"<s0>zip</s0> :: 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",
"<s0>pair</s0> :: 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: <tt>pair a b = (,) <a>$</a> a <a>*</a> b</tt>.\n",
"\n",
"<s0>zip</s0> :: (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",
"<i>O(min(m,n))</i> Zip two vectors\n",
@ -3069,9 +3056,17 @@
"URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector.html#v:zip\n",
"<i>O(min(m,n))</i> Zip two vectors\n",
"\n",
"<s0>pair</s0> :: 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: <tt>pair a b = (,) <a>$</a> a <a>*</a> b</tt>.\n",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: 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",
"(<s0>>*<</s0>) :: 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",
@ -3096,21 +3091,6 @@
"Merge two functors into a tuple, analogous to <tt><a>liftA2</a>\n",
"(,)</tt>. (Sometimes known as <tt>**</tt>.)\n",
"\n",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: (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",
"<s0>zip</s0> :: 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",
"<s0>zip</s0> :: 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",
"<s0>mzip</s0> :: 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",
@ -3134,25 +3114,9 @@
"URL: https://hackage.haskell.org/package/relational-record/docs/Database-Relational-Documentation.html#v:-62--60-\n",
"Binary operator the same as <a>projectZip</a>.\n",
"\n",
"<s0>biunfold</s0> :: (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",
"<s0>biunfoldBF</s0> :: (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",
"<a>choose</a> calls.\n",
"\n",
"<s0>deserializeWith2</s0> :: (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",
"<s0>biunfoldRestrict</s0> :: (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",
"<s0>biunfoldRestrictBF</s0> :: (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",
"<s0>mesh</s0> :: 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 <i>mesh graph</i> from two lists of vertices. Complexity:\n",