\n", - " This is an example of BlazeMarkup syntax.\n", - "
\n", - " \n", - " Hello\n", - " \n", - "\n", - " This is an example of BlazeMarkup syntax.\n", - "
\n", - " \n", - " Hello\n", - " \n", - "![](\"https://www.google.com/images/srpr/logo11w.png\")
\n",
- "\n",
- "\n",
- "\n",
- "\n"
- ],
- "text/plain": [
- "\n",
- "\n",
- "\n",
- "\n",
- ""
+ "\n", + "
\n", + "
\n", + "filterM (pure (pure True)) = cat\n", + "\n", + "filterM (liftA2 (liftA2 (&&)) p1 p2) = filterM p1 >-> filterM p2\n", + "\n", + "\n", + "filterM :: (a -> IO Bool) -> InputStream a -> IO (InputStream a)\n", + "URL: https://hackage.haskell.org/package/io-streams/docs/System-IO-Streams-Combinators.html#v:filterM\n", + "Drops chunks from an input stream if they fail to match a given filter\n", + "predicate. See filter.\n", + "\n", + "Items pushed back to the returned stream are propagated back upstream.\n", + "\n", + "Example:\n", + "\n", + "
\n", + "ghci> Streams.fromList [\"the\", \"quick\", \"brown\", \"fox\"] >>=\n", + "Streams.filterM (return . (/= \"brown\")) >>= Streams.toList\n", + "[\"the\",\"quick\",\"fox\"]\n", + "\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/protolude/docs/Protolude.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/protolude/docs/Protolude-Monad.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: (IsSequence seq, Monad m) => (Element seq -> m Bool) -> seq -> m seq\n", + "URL: https://hackage.haskell.org/package/mono-traversable/docs/Data-Sequences.html#v:filterM\n", + "The monadic version of filter.\n", + "\n", + "filterM :: (Monad m) => (a -> m Bool) -> Stream (Of a) m r -> Stream (Of a) m r\n", + "URL: https://hackage.haskell.org/package/streaming/docs/Streaming-Prelude.html#v:filterM\n", + "Skip elements of a stream that fail a monadic test\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/rio/docs/RIO.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: (Monad m, Vector v a) => a -> m Bool -> v a -> m v a\n", + "URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector.html#v:filterM\n", + "O(n) Drop elements that do not satisfy the monadic predicate\n", + "\n", + "filterM :: Monad m => a -> m Bool -> Vector a -> m Vector a\n", + "URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector-Boxed.html#v:filterM\n", + "O(n) Drop elements that do not satisfy the monadic predicate\n", + "\n", + "filterM :: (Monad m, Storable a) => a -> m Bool -> Vector a -> m Vector a\n", + "URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector-Storable.html#v:filterM\n", + "O(n) Drop elements that do not satisfy the monadic predicate\n", + "\n", + "filterM :: (Monad m, Unbox a) => a -> m Bool -> Vector a -> m Vector a\n", + "URL: https://hackage.haskell.org/package/rio/docs/RIO-Vector-Unboxed.html#v:filterM\n", + "O(n) Drop elements that do not satisfy the monadic predicate\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/rebase/docs/Rebase-Prelude.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", "filterM :: Monad m => (a -> m Bool) -> [a] -> m [a]\n", - "URL: http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:filterM\n", - "This generalizes the list-based filter function." + "URL: https://hackage.haskell.org/package/yjtools/docs/Control-Monad-Tools.html#v:filterM\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/llvm-hs-pure/docs/LLVM-Prelude.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/universum/docs/Universum-Monad-Reexport.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: (Applicative f) => (a -> f Bool) -> [a] -> f [a]\n", + "URL: https://hackage.haskell.org/package/haxl/docs/Haxl-Prelude.html#v:filterM\n", + "See mapM.\n", + "\n", + "filterM :: (Monad m, Vector u a, Vector v b) => ((a, b) -> m Bool) -> Vector u v (a, b) -> m (Vector u v (a, b))\n", + "URL: https://hackage.haskell.org/package/hybrid-vectors/docs/Data-Vector-Hybrid.html#v:filterM\n", + "O(n) Drop elements that do not satisfy the monadic predicate\n", + "\n", + "filterM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> t m a\n", + "URL: https://hackage.haskell.org/package/streamly/docs/Streamly-Prelude.html#v:filterM\n", + "Same as filter but with a monadic predicate.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/yesod-paginator/docs/Yesod-Paginator-Prelude.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/control-monad-free/docs/Control-Monad-Free.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/hledger-web/docs/Hledger-Web-Import.html#v:filterM\n", + "This generalizes the list-based filter function.\n", + "\n", + "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", + "URL: https://hackage.haskell.org/package/relude/docs/Relude-Monad-Reexport.html#v:filterM\n", + "This generalizes the list-based filter function." ] }, "metadata": {}, @@ -1843,10 +2016,7 @@ }, { "cell_type": "markdown", - "metadata": { - "deletable": true, - "editable": true - }, + "metadata": {}, "source": [ "The other provided command is `:hoogle`. This does a normal Hoogle search, and thus lets you use imperfect matching and searching by type signature. This will show you documentation for things that match the desired type signature, as demonstrated below. It automatically formats inline Haskell code and hyperlinks the identifiers to their respective Haddock documentations." ] @@ -1854,11 +2024,7 @@ { "cell_type": "code", "execution_count": 25, - "metadata": { - "collapsed": false, - "deletable": true, - "editable": true - }, + "metadata": {}, "outputs": [ { "data": {}, @@ -1949,281 +2115,1187 @@ ".suggestion-name {\n", "font-weight: bold;\n", "}\n", - "zip ∷ [a] → [b] → [(a, b)](package base, module Prelude)
\n", + "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n", + "\n", + "\n", + "If one input list is short, excess elements of the longer list are\n", + "discarded:\n", + "\n", + "
\n", + "zip [1] ['a', 'b'] = [(1, 'a')]\n", + "zip [1, 2] ['a'] = [(1, 'a')]\n", + "\n", + "\n", + "zip is right-lazy:\n", + "\n", + "
\n", + "zip [] _|_ = []\n", + "zip _|_ [] = _|_\n", + "\n", "
\n", + "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n", + "\n", + "\n", + "If one input list is short, excess elements of the longer list are\n", + "discarded:\n", + "\n", + "
\n", + "zip [1] ['a', 'b'] = [(1, 'a')]\n", + "zip [1, 2] ['a'] = [(1, 'a')]\n", + "\n", + "\n", + "zip is right-lazy:\n", + "\n", + "
\n", + "zip [] _|_ = []\n", + "zip _|_ [] = _|_\n", + "\n", "
\n", + "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n", + "\n", + "\n", + "If one input list is short, excess elements of the longer list are\n", + "discarded:\n", + "\n", + "
\n", + "zip [1] ['a', 'b'] = [(1, 'a')]\n", + "zip [1, 2] ['a'] = [(1, 'a')]\n", + "\n", + "\n", + "zip is right-lazy:\n", + "\n", + "
\n", + "zip [] _|_ = []\n", + "zip _|_ [] = _|_\n", + "\n", "
\n", + "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n", + "\n", + "\n", + "If one input list is short, excess elements of the longer list are\n", + "discarded:\n", + "\n", + "
\n", + "zip [1] ['a', 'b'] = [(1, 'a')]\n", + "zip [1, 2] ['a'] = [(1, 'a')]\n", + "\n", + "\n", + "zip is right-lazy:\n", + "\n", + "
\n", + "zip [] _|_ = []\n", + "zip _|_ [] = _|_\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zipExact xs ys =\n", + "| length xs == length ys = zip xs ys\n", + "| otherwise = error \"some message\"\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\n", + "\n", "
\n", + "zip [] _|_ = []\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",
+ "zip xs ys = zipWith (,) xs ys
\n", + "concurrently left right =\n", + "withAsync left $ \\a ->\n", + "withAsync right $ \\b ->\n", + "waitBoth a b\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",
+ "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",
+ "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", + "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 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", + "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",
+ "zip xs ys = zipWith (,) xs ys
\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 +3308,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 +3316,7 @@ { "cell_type": "code", "execution_count": 26, - "metadata": { - "collapsed": false, - "deletable": true, - "editable": true - }, + "metadata": {}, "outputs": [ { "data": { @@ -2288,10 +3353,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 +3361,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 +3374,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 +3382,7 @@ { "cell_type": "code", "execution_count": 28, - "metadata": { - "collapsed": false, - "deletable": true, - "editable": true - }, + "metadata": {}, "outputs": [ { "data": { @@ -2360,10 +3411,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 +3419,7 @@ { "cell_type": "code", "execution_count": 29, - "metadata": { - "collapsed": false, - "deletable": true, - "editable": true - }, + "metadata": {}, "outputs": [ { "data": { @@ -2477,10 +3521,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 +3529,7 @@ { "cell_type": "code", "execution_count": 30, - "metadata": { - "collapsed": false, - "deletable": true, - "editable": true - }, + "metadata": {}, "outputs": [ { "data": { @@ -2522,10 +3559,7 @@ }, { "cell_type": "markdown", - "metadata": { - "deletable": true, - "editable": true - }, + "metadata": {}, "source": [ "Thanks!\n", "---\n", @@ -2549,7 +3583,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 +3605,5 @@ } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 }