From 0124ab07a0bb695fb27af56d703e2d4150936b67 Mon Sep 17 00:00:00 2001 From: Vaibhav Sagar Date: Sun, 11 Nov 2018 01:32:42 -0500 Subject: [PATCH] notebooks/IHaskell.ipynb: update --- notebooks/IHaskell.ipynb | 683 +++++++++++++++------------------------ 1 file changed, 269 insertions(+), 414 deletions(-) diff --git a/notebooks/IHaskell.ipynb b/notebooks/IHaskell.ipynb index 7dcae964..ef85c0ab 100644 --- a/notebooks/IHaskell.ipynb +++ b/notebooks/IHaskell.ipynb @@ -1343,7 +1343,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAAEsCAIAAADfNCTgAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3dd1QUVxsG8Ge2UUQQ7NgRC6hgPrFgFAtW1NhR7N3EFmsSNVE0amKMLaixJlGjYsMexYYVG4rYGyIWBKQpnS3z/YEFYRcWZndnZ3l/J+dEmbsz7y7wOHPnzr0My7IghBBSVCK+CyCEEGGjGCWEEE4oRgkhhBOKUUII4YRilBBCOKEYFZzMI8NLi5j3RCKJuXWF2l/2nbnjTrKWYy7YmPUdzRmGkdT+7rK8wNaqmDNr5/v6+v68KTjhwwEKt4dC+ezdMSKR1MK2ikuH0ctOv9LxgTQw6g+HGCkJ3wUQTlhWmZkc8zh4z6+Xzz9lbvr3r8Do+AiqmLNrf54XppA2s/IZ1txOrOPd549lFRlJL2+f2Dj9zOl7ey9v6FZW12+PG14/HGI06GxUsMTVhm29FnotaOukJiUZQBV78O9DMYYZBMzYdpofcOjQoQPrh9fV0z/E4mrDtoaEhl49vXWyeykRWHnE1p83PVTq52A6ZYAPhxgblghMxuFhdgwASe3vrshZlmXfbuthwQCQNJgTKv/YLPPZsV9HeNarZGMuM7ep7Oo1Ye3lOCXLsiyril7XwQyAuNaMS1ksy8pvbRzVrUWDGhVsS8ikZiXLOTbrNWNr2FsVyyoeLm4qzfUDI20475Y85x7ST42rKgaYUn38E1TvSzwzsZoYYKy8Nr1W5V9Mge+OzTg+tqIIAGPZd1dq9lci/vtlWFtne2tzmblNpXqeIxYHPsvM9da+9Q/4qYervZW5ZVnnLj8ciMjK3r3i1ryGUgBSt0X3FCzLsvIr39WWAJC1WfVCqfsPh9W64Mm7Dy/o51bF2szczrHdtIAPBRMhoBgVnDxBk+zf25IBIPNY+ex9NsmfbOpeUcwAjNjCrqytuYgBGAuXaUGJqrxJkXFgkDXDiC1sK1SqVNZKygCAqFzvf18ptUuKjHOTHcQAU6rvzsTs0Dz3bXUxwNj0/PeNqoBiCnx3bMbxMTljVP54Y7cK4s+v7RlJpV6bIxSf3hpjZmkptSxfo1ppMwYAY+Y87ew7li1CjHL9cLQuuEQJqdjc2sqMYQAwJdv/+Uz9vzPECNFFvWCxqvSkuLjo8LN+m85ksGCs3Ht7VRYBAJt02HfWoddKplxXv7DYuNi4l0HTGsqQfnvVzPWP8l4XS+oO2Xj2Sfy7hNcvX8YmPj80xlEC1ZvDGwNeMrW/u5wW5usqASBttuSxgmXZrNA5DT7vAzRr1r9PTQnYtyf3nngLIOtqwKEXSohsO/l0Kc0UspiP7y4z9lHYzZshZ7bNnLsrRgUw0vqNXMzYpEO+s45EK1lx1b4bbr5Jjr2+uoe9mFW82j9zwfGUT6+WW7Vfe+fF02cvrv3a0ophM++vXeQfpcqxf5FIux99rh+OtgVnib6YezkmMeG+XzsrBmzK+QMn4+kxbaGgzhvBUj7x61jRDwDAmFdu8+2fm8c5Zv8Ky68HnnqjAkSqp7u/7bEPAJvwhgHYrJtng5Nm1M61I3FtD/e4PRvnLL/3Ii45Q54ZmcoCrOLpowglqmoTNtJG/b3rLltw5+2JgJNv+3x1d9+hSCVE5boM6FSKQVb+xdQprf6mkTLyn8Fu/3z8KyOtPnD2iNpi+anA03EqQNpg1JzhrmXEKDNm1hC/w78+UMScPnFT3qlWdnORbedRPjWkgLT+sCFfzjkfmJl25VxI1uivPp4+Mox2N6u4fjjyEK0KZqy9vp3kZi1CiVYetSQnQuXK2NexKpSlm1aCQDFqErKSop6/Sf1wtqWMj0tiAaji7p09dS9nO1VSYhILq89emxG6uH3bWReSVJ99FWxmRqa2p0MSl37eDRbfCX17POBkvP3lg8+UEFX8akC7kloUoyFGszGMWFayvGPjTkO/953cviyD9IT4JBaAqGKlCtkhJqpQqYIID6BKiEv4+BYYm9J2kk9/YpDJpicmpLGw+fj2PvxfxeY3OQ/nD0epXcGispUrmQMAzMxkAMAqlUo6GxUKuqgXLEnt7y5nZkRf+aN7JZEq5aH/+KFL72SPUxTblSnFAIyZ559Rn3c/Zl6cWjPXtzzr/LoVwUkqRlpvwqGIZAWrit3YySzHdq1O2sRO3v3+J2NUSYH+v20+8EwJceWePq0tC13MZ+/uipxVqRQZb1/dOblpRvsq0uy9lS7FAFC9fhWdnUGq6Ow/iezK2H3cm+pN5PO07D+9jnwpZwHGwtbOkgHE4uwTvKyMTABAZtSLN7kyUqcfjpYFgxG935e2p8nEiFCMChkjMivfZMLaX78qLQKbHrLs54A3LACpW0fPMiKwWef/mLvvWQYAKN4+Cdr0Xa/xO97kPsVRvktKZgHIajZpXs1KrHh+cP+1z0aNW1haZOfAo0fvNPZlimv17d9ExqgS96/464kC4uq9B7TIPrsqVDEFkrp1aFNaBMhvb/z571vxqXGhGxZteawAROXatGv48ZKdTTm6ZN7hx2+ib2+fu/qSHGAsm7VyMwNEZSuWEzOA4snZoAg5mxq2xu/oW81VcP9wtCyYCJvBbmYRHcl7Lzvz+k8uMgZgZA3nhmaxLMvKn/zVw17CAGAkJcraV7SzFDMAzDpuiFHluhmtfL6hsw0DMGJb5/bdO7mWty5hyQAQlR8dmMmyLJt+8pvKn7roRBW/PpGZ+3Y2y7Ks8vnqthbvT6QkdX+48mnATr7FFPzucpE/XOtVLveNb3HF7n+F57jxLbK2t7fOcapn5jz1zLvsMiPXdrBmAICRWtmUkEgsLM0YaLpTr4sPR6uCP36SisdLmkkBSFx9w9S+f2KE6GzUBMi+mDirRxkR2Kxba37dF8cCkprDd146umRMR9cqJVVJ8cni0o5unUf8uPL7Dra5LxlFVYZv9P/pq/plZSlPr99OafTj7oVtcl63wrzNj+u/7+xczlKS7+WmqHJPn1aWDABInLz7/e/TiVYhitGCpPbYvZf2/zyktVOFkmZSs5IVndoMXXjo4s7hDjluxzDlB2w4tHRQkyolzSzKOHl9t/Pwr61KZpdZdeT6LdPa17Izl5rZ1PT6KWDL2Gqa7+Po4sPRqmAiaAxLs98Tk8HGrO9UbezxTHGtGRfu/taMrpmJQdDZKCGEcEIxSgghnNBFPSGEcEJno4QQwgnFKCGEcEIxSgghnFCMEkIIJxSjhBDCCcUoIYRwQjFKCCGcUIwSQggnFKOEEMIJxSghhHBCMUoIIZxQjBJCCCcUo4QQwgnFKCGEcEIxSgghnFCMEkIIJxSjhBDCCcUoIYRwQjFKCCGcUIwSQggnFKOEEMIJxSghhHBCMUoIIZxQjBJCCCcUo4QQwgnFKCGEcEIxSgghnFCMEkIIJxSjhBDCCcUoIYRwQjFKCCGcUIwSQggnFKOEEMIJxSghhHBCMUoIIZxQjBJCCCcUo8S0pPr3rjDkUGaRX68KX9rac+UzlQ5LIqaOYpQQQjihGCWmjk0O8fNpXKdO3doNOs0+Fq2C6sWqdi59Jo717tW5uVvnhcHJLNi3wYu71nOs18jDxy80TdtXEQKAYpSYPEXY72M2llt86cGDsB2ewRNnHnkHQPkqqc732wOOnl5Wx3/J/gT5zaXj/eusvX4n5MgUizv35Nq9inKUZKMYJaaNjb10OauDT0s7BhbOPn2qh1y4rwAkjq1aV5MAZo51KsW+jIm+fEXZsZ+7DcOUdOvfva5Eq1fFUv8pyUYxSkweCybnXxkAEIvFAACRSKRSsQAkUkn2VolMov2rCAHFKDF1TDl3d1ng9vMJLNLvbt/zrHFLJ0neNs2aic+fDpcDimenTj5UavUqQt6jnw1icpL3Dq952hwAJHW+PXx8+vT1I0eNbeKYpDKr2d9vs1dJvMr9CknDqSs7DR3R7px9WRtbm6piQOJa8KsIycawLF2bEEJI0dFFPSGEcEIxSgghnFCMEgGTy+VSqZThia+vL98fADEKdIuJCFhkZGSVKlWePn3KdyGkWKOzUSJgT58+dXBw4LsKUtxRjBIBe/r0ac2aNfmughR3FKNEwCIiImrUqMF3FaS4oxglAkYX9cQYUIwSAQsPD6cYJbyjGDUC7JszC3t+4Vizdh3HWq7tF1zIyLc1Tc/+SUREBMUo4R0NeOKf/NKvY/fU/vtGQHNrJism7EGWmO+KhCE+Pp5lWTs7O74LIcUdnY3yTxUXm2hjX6kEA0BW3tWlCnNzbuO2KyNUAKC48VMjz5URqjzTs6ubjD3j4bZv2jZs0KB+vWYDVoemKNTsh883qmN0m54YCYpR/slajR6TsaiJi2e/cXPXnQhPhaTB4P6qnTseKIHMS1sP2A/wrq7KMz078kzGrrj/x7itDn7Bt2/fCVnvtHPKugjnPPsxpe833V8iRsKUfq2EirHxWBD8+NKGSR2qxu8e7d51xQM4+Ay0278tVJ4atPWE06CeFRCbe3p2IM8U7jHnTt18sGucV+vWrTtPOpyUGhvF5N4PU0ApgkJno8RIUN+ocRBZOzTv7tC8e3/nd7WWHX85aWLvwTXb//ufU+zFpoOX2TGIUjM9e+7J2FUsa9ttyQm/1rJP+2Vz7ceURERENGrUiO8qCKGzUSOgfHQy4HqsHACb/PDmE1S0LyVi7LoMaXRy/A832g5qZ6Vueva8mPIenmWPrPaPyAKgTLwf9jQdyLUfk0KjnYiRoLNR/rFZkQenT57+LJ1hVRZ1eq9e190GgFUb75bii6UGt8iexj3P9Ox5iZ0nb1k0Y2zXeotYCWRVfVbsdnWwyLUfU0J9o8RI0Oz3xkp++2ePryV/nZvpxG38k672Y3wWLFjw/fffS6VSvgshxR3FqDFS3lnZw3vVm86rjvzesTSHDk1d7YcQkg+KUUII4YRuMfHP19eXr/nbrays7t69y/cHQIiw0dlosbZjx46FCxdevXrV0tKS71oIESqK0eJu+PDhDMP89ddfPB0/GXgIRADRQBTwAogB3gEpQAqQBGT/fNoADGAOlP7wX1mgKlAVqAZUA4zxyfq3gA3fNRADoBgt7tLT093d3adMmTJ06FCDHPAtcBUIAW4Dd4FwQAEoAeWHxNQeA4gBMSABqgCNgC+A+kAjoIxeai+Md4AH0B6YB9CpvmmjGCV49OhRq1atTp065ezsrJ8jpAMXgCDgPBAGZABy/RyIASSAGfA/oA3QAnAHSujnWAWYCKwBGKAZsB7Q0ydLjAHFKAH01UmaABwDAoFjQBKQpbs9a0kG2ACdgG5AR8DaYAc+BvQAMj/8tTywGuhtsMMTw6IYJe/prpNUAZwG/IEDwFtA3ZOrhiYBbIDOwECgnb4f3osHmgOPPv+iGTAdmAeY2lMQhGKUfMS9kzQqOepG9L6utVYBT/k499SGDHAAhgEDgCp6OsZoYJO6jl4J0BtYb8izYmIQNG6UvGdhYbFr164ffvjh3r17hX3tndg7009Md/nTZcT+eZnKEsaaoQCygAfALKAeMAgI1fkB9gFbNdwsUwC7ga5AjM6PWqBU/94W0jrTL2YAgCp8qUfjebcUhd2J6sXf3Z36bovKnvw7+cxk1+YLb+X7rVa9WNW++aL7xnBBok8Uo+ST2rVrL1u2zNvbOy0tTcuXXHt1rdfOXk02NFkavDQ+PT4+Lf5CpKPRX7mqgGRgG9AC8AEu62q/McCUHF2iag98AegIROjqkNorUT59/+87X3O4+hRVGbJ0XNKiH4/Es8gIWfLd+c5Lp7jINLdnlcrica1LMUo+4+Pj07hx4wkTJhTY8mHcw9EHR7fZ3Gbfg33pivTsL6qgmh0UBpTWc5m6kgb4A22APsAd7rubCjwvqA0LhAGdAAM/PcaUaD/JJ2rl6us5Th9zrTqjfLzEo90fz1WQX5zqUKLd2igWWafG1R+yP/XDC8SOY5cNevjj/BNXV00/0GTxrGaWYJND/Hwa16lTt3aDTrOPRauyl7fpNW54r6+8Jvi/er9sTebjLQObeS259s6wb9pAKEZJbmvWrLlx48bmzZs1NYhJjZnw3wS3DW4bQzemylNzbQ2Lfhb5trmea9StDGAv4A6MBl4UeS/bgT1aj319BHQD7hf5YEUhrf/11Np7f98X9z7alLlXnXlapXnjuOBLKcqI4Ftl6qVeupKqeHjxRpUvm+YYvSFrMHlZl3MDOm6oPt/X05qBIuz3MRvLLb704EHYDs/giTOPvAOgfB7nOHPnwaN/DqwsApB2d/2gQXubrts9o7FpdgtTjJLcLCwstm/fHhsbm3eTilVtvbXVbb3bmmtrUrJS1L48Q5Gx5loqILj5TVOATYAbsKoIowteADMK2SUcAXwFPC7skTgQle05vffj5WvvyAGAfZNn1Rmxa4sG9y5ej718xWLglKbPL4a+vnyFbeZe7rPZwSwajxrsXL7LaK8yDMDGXrqc1cGnpR0DC2efPtVDLtxXAGLHtp4O7ycwVL3aMWLAAY+//Ce58jOA1wBo2maihrOzc96h+KHRodOOTzsfeV6hKuDmxPrr13xb/c9CGqy3AvWEBWKBKUAAsAxoqP3LpgGvC3+8J0Av4AhQtfCvLRJZo/GTKrRdeqQ3CynUrDqjetXcfsnpHelJjcZ3qh/y9+ldMS8aDauTu6dbJBaLxB/PwFh8lrIMAEYmk334ImPr1LTso6DgyDH16prp633xjM5GScEUKsWqq6va/NMmKCKowAwFkJSRdPxpZcH+I60AgoB2wDUtX/AXsL/wj7Jmuwv0ARKK9NoiYCr2m9El9I8tz5RqV50RlW/WJH3LH9drf+lk07QZ/ll5qXaLRvmFH1PO3V0WuP18Aov0u9v3PGvc0inXd52xbDh5558Nt/uM2B6hp2fXeEcxSgrw/O3zHjt7TAmc8jbzrfavmnnyGstW1F9VesYArQA3bZo+A2ZzeLiVBUKAYYYbI2buPmli3aQY1ftVZyr+07VeXWenem0m738uByTOX7plJVRt7iYTVXRvYhlX4ctm+XdnSlynrx8ZM6OJY816/U66+y30Kpm3DWPj/tOepZVW9R23/5We3hW/aPg9yc+ee3smHp0YnRJd2BfKRLKwb7rVLRNQ1LM0flUAgoEaBbZTAd2Bw5yPJwYmACs474fwgs5GiXoKlWLBuQWD9w0uQoYCyFJl/RYcI8y5jWTAUm0yFMCfwDFdHFIJ/Ams08WuiOHR2ShRIz49fsyhMQcfHtSmJ1QTa5n1i2mNrGVBOixM/xigD7ATKHjtqofAl0C87o5tDZwAmuhuh8Qw6GyU5PYw7mHbf9ruu7+PS4YCeJf1bv99W0BYK3dWBlZok6EKYLxOMxTAO2AE59tNSUlJM2fOtLS05Gtlmvz5+vrq5LMyKhSj5DOh0aFdtne5FXuL1UWfpu+ZqypWq6tj4yADVgL22jRdDpzVQwX3gUlF7U7Oyspav369k5NTeHj4vXv3WKNEMUpM3Pnn57ts6xKeGK6rHb54Fx0W3VAgP2YM0B/oqU3TMGARwOlcXQMVsAv4t7CvUql2795dt27d3bt3BwYG7tq1q3r16nqojqhHfaPkvUOPDg0OGFyoUU3a6FG38b5+DwHjf5i6JhAMlCuwXSbQDrigz1IqAVeASto1Pnny5PTp0y0sLBYvXuzh4aHPuoh6gjhNIHp3OuL00H1DdZ6hAE4+vR+f7q7z3eqaGbBCmwwFsBi4pOdqooAZWjS7cuVKmzZtJk2aNHv27EuXLlGG8oVilOBs5Nl+e/olZiTqY+cpWSk7bpsD+cynxjsRMBroqk3Tq8Dv+p/QnwX2Ans1N3jw4IG3t3ffvn19fHxu377dt29fPVdE8kMxWtwFvwzuu6tvXFqc/g6x4PwlhaqW/vbPWW3gZ23apQPjgWR9lwMAyAJmqTvWq1evxo4d6+Hh0ahRo4cPH44ZM0YsNvLZXU2fQJ96JroRkRQxaO+gN2lv9HqUNylxV161+bLKA+NYlykXC2AVUEqbpvP1MV2+Zk+AVcDMz7+4bds2Ozu7R48elSqlVc3EAOgWU/GVmJHY8d+O115pOwEHF62q1z8z9LWux1lyJwKmAb9p0/Q80AnQdlUAHSkDXDfc/E+kiOiivpiSq+SjDo4KeRVimMNde/k0KvlLwxyrMFyAOdq0SwbGGzxDAcQDCw1+UFJYFKPF1Ovk15FJkQxT8OM6OpGmSNt4Qw4Y1YSTJYDVgJU2TX8y+Jof2VhgG1DoJQaJYVGMmq5ly3D7tqaNVW2qBg0NGthgoERkoP7xlZevZCpcDHMsLYiB6YBWi50cB9YBKn1XpEEq8AdPhyZaohg1UQcOYPZstG0Lf39NTUqaldzcY/PyjsstpYaYhykpI+lMpIPRLBrqBnyvTbsEYCKQoe9y8rUdeMJrASR/FKOm6OlTjBuHjAzExWHYMMyYAbn6aYUZhpnQZML+fvur2FTRd1EqqGadCmVRVt8H0oI1sBqw0KbpTCOIsBQ6ITVuFKMmRy7HyJGIinr/18xMLF+Ovn2hbom6bO1rtg8aEtS8SnMRo9+fhzsxzyKSmmszf5I+iYFZQCNtmv4HbObvcv4jFtgO6HdUGuGAYtTkLF+OC58/8K1U4uBBtG6NEI335Wva1QwcFDjMdZhUpMd57bJUWSsuJfK9aOiXwBRt2sUB3wKZ+i5HO4nADr5rIJrQuFHTcvs2WrbEWw2PxtvZYeVKDBqk6dUsy66+tnrmqZmaFk/mrpR5qVdTGljKzutp/wUeHzgDuGrTdATwjzEtgVIfuGk0XcskJzobNSEKBSZO1JihABISMGoUJk5Eerra7e+7Svvvr2ZTTU81JmUk/fekPE+Pz0kAXy0zdCewzZgyFMAj4CTfNRC1KEZNyMaNCC5oafjMTPz5J7p1w8uXmpp41vA8PfR0y6ot9dRVOifoOstqOQmcbrUCxmnT7jXwneGW6tRWVr6TlRAeUYyaipgYLFig6Y78Z5RKnD6NNm1yd6Hm4GDrEDg4cFzjcfroKn2c8OJ+XBOD32gqA6zSZkUTFpgCvDBARYV3AEjluwaSF8WoqZg//9Pd+QKxLJ48QdeuWLVKUxMLiYVfZ79N3TfZmNnopsIPFCrFwnMvgRK63W2+pMBCoK42Tf8BjHZV6ATgKN81kLzoFpNJuHsXzZohpfD3hWQyjByJpUthoXEQZfDL4GH7hj1JeKKT1ZmyWcusI6c2LmV2Slc7zBcDdAYOaXPSEAG4AzEGKKqoBhZ+iRGib3Q2ahLmzStKhgLIysL69fDyQmSkpibNKzc/M+xMO4d2YkZnd4nfZb3be9faUIuGlgP8tPlRVwHfAhqH1xqHE4D6+4OEPxSjwnf5Mg4dKvrLlUqcPQtPT5zXOAjJvqT9QZ+DE5tOlIl1Non9vLOXlYZYNFQKLAEctGm6FjhmrJfzHyUBl/mugeRCMSp8S5cig9sz3yyL8HB4eWHVKmjo5DGXmC/vuHzjVxvtLOw4HeuD1ylvbuh90VAG+ArQOE42p0eAL6DFHTqeZQGn+a6B5EIxKnA3buDIEd3sKiUFU6di7FikaZxXc7DL4P8G/Fe7dG2G8312hUox5/RjwJrjfvJVCVipzZAABTBeOE9bBvJdAMmFYlTg/Pw0jaUvCrkcmzahc2dERGhq0rRy0zPDznR07Mi9q/Tcs4exqVpNVVckMmCZlqsUrwTO6K0Onbtn9B24xQ3FqJC9fImAAB3vU6XCuXNo0QLHjmlqUtGq4v7++6e4TzETc5qGOU2RtjVMpJ+5nBmgH6DVepl3gIWAQg9F6EkWcIPvGkhOFKNCtnkzkvWzTmVUFHr3xoIFUKmf3shMbLak/ZItPbeUteQ08d1vF6/IlU5c9qBBDeB3bdplAuMBvSwtrTdy4CbfNZCcKEYFKysLf/+t6Y6QDqSlYf58jByZz1Aq73reJ4ecbFCuQZG7SuPS4oNf1tH1hBtmwHKgnDZNfwcu6vTYhnGV7wJIThSjgnXyJJ4/1+8h5HJs2YK2bfHggaYmLuVdTg873aNuj6J1laqgmnP6LmDLocpcGGAE8JU2TUOAxUa56HOB6KLeqFCMCpa/v1ZP0HOkUuHaNbRti8OHNTUpY1FmV99dvq19zSVFmUj0atSTl+90uGhobS0X00wDxgH66RPRuzjhjCsoDihGhSkhQWfjnLTx+jW8vfHbb5q6SiUiyY8eP27rta1cCa0upXPKUGSsC8nQ0VzO5sAqLc9tFwn5nE4BhPNdA/mIYlSYjh3Du3cGPWJ6OmbPxsCBSErS1KSXU69TQ041LN+wsF2la65dy5A35FyiCBgPtNOm6RVghTAv57MpjGCFKPIRxagwHTsGhcGH6CgU2LkT7drhnsaF0+uXq39q6Knezr0LtW5zUkbSqWfVOM/l3ACYq027FGCswGecUwIaR/YSg6MYFaD0dATy9CQLy+L6dXh64sABTU3sLOz8+/jPbTXXQqLV0pt4v2hoCKvdvXUNSgCrgJLaNJ0L3OZwJCPxmu8CyEcUowJ04UI+V9aGEB2N/v3zWbdZzIh/9PhxR58d5UuU13KXD968CE9wL+pczmJgCtBCm6ZngT+NYLFP7ox5Nr/ihmJUgC5cQBbfK1xkZGDFivzXbe5ep/v54eebVm6qzWIkWaqsJRfjtFw7Po+GwA/atHsLjDOVieai+S6AfEQxKkCnjWOKH4UCBw+ibVuEhmpqUqt0rRODTgxyGaRNV+mue2EpWW6Fr8MKWK3lXPozAY0jYIWGYtR4UIwKTUICbhrNo4Asi7t30bEjdu/W1KSkWcl/uv+zvONyS6ll/jtLykg6+LBsIedyFgMzgabaND0G/GUSl/PZDDtQg+SHYlRoQkP5v6LP5c0bDB6MGTM0FfZ+3eZ++6vYVMl/T3OCrqrYAtp8rikwVZt2ccAkILMwuzZyGSb0T4LQUYwKTWioIR5eKqzMTCxfjl698ukqbV+zfdCQoC+rfJlPV2nk29d3Y920vtFkA6zWctz+96Y40NKU/lUQNIpRoblxQ4/TkXChVI1mIegAABXdSURBVOK//9C6Na5f19Skpl3NY4OODXMdpmndZoVKsfDcc+06OiXAHECrQfu7gJ2ABJCa0H8iilGjQSuDCo2LC24b96hHW1usXInBgzVtZ1l29bXVs07NSs5S80S7lczq+ZTmtubHCzpMGyBQy47UMybak9hBR4/QEo4oRgUlNRUVK+prjlEdkskwejSWLMln3ebTEadHHBgR+VbNiqRru/Yc2+gIkE8XcGngPKCPiUoJKTS6qBeUx4+NsWM0r6wsrF2LXr3wWuOzNm1rtA0aFtSyasu8XaU/n7mkUNXUvHcJMJ8ylBgPilFBiYjg4VH6olEqERiIli3zWbe5RqkagYMDxzUel6urNCYt7vprF80/nO2BsTqtlRBOKEYF5fVrKIUzLVH2us1du2LVKk1NLCQWfp39NnXfZGNm8/GLCpViTtADwEbdK8oBq3Q9Wz4hnFCMCsqrV0Z6mz4f795h2jR8800+K5gOdhl8dNDRWna1Ps6wdyHycXRK3rmcpcBiwEFvtRJSFBSjgqK5q9GoZWVhwwZ06YIXLzQ1ca/sfmbYmfY122cvRpKmSPsnlP180VAG6AYM1X+5hBQOxaigxMfzXUFRKZUICkLLljh7VlMT+5L2B/ofmNh0okwsA7D08pVMZf0c2ysBK4s6BRQhekQxKigJCXxXwE1k5PuuUg1dE+YS8+Udl2/8aqOdhV1CWsKFSMcP3aAy4HegsiGLJURLNG5UUOrXx927fBfBmVSKYcOwYgUsNU5WcvXV1SH7hthaMJdGJgKxwEBgqyFrJER7dDYqKJkm8fifXI5Nm9C2LR4/1tSkSaUmZ4adKWdZO/Jtc6A6sNSA9RFSOMUsRlP9e1uIK4w48n4dnncBA8uIrXwCihBOqher2jdfdD/f0Uds7MYubnNu6nCgp2nEKACVCleuoHVrHD2qqUkFqwq7vHc9jm8OLAen9UUI0S+Oi4gJD1PKqfztgKCULl2tkHQ8ILyyk/6eSmZsuy3ZlFlNh5+xUMbeaykqCn374uefMXkyGDX3jszEZi/OTrdzM7X3DcDKClFRfBdBdKTYxShkbr1bPNh7OrlrN0VgwEvPXvWe3QcA5Z0FX06z23t0XCWR8uHiVuPM/w3sdbhzjyuu9Z6fuBTJNp6zfmTUbz/633xt1ePPg0s7lwPAZtz+c7BH8K2o9KrD122b1cLq6m89p+6OSklJkzX8duOmb1wtEg/NGPl84eX5DXX1MZteR3ZmJqKi1GYogFOn8O23AphCoAhs1D5bQISpmF3UA4CsUe9WjwNOvU04tu91u1718ks4RfgTmyn/hT04+/Wb7wf8XW3F+Tt3d7Q89dv2ZyoAUD66ZzHh8LXboX81PDDh9xsKifOorWeu3Qi7f32Nw79z/GP0EHlmZgW3ERCRCH364Jdf1G68fRuDBplmhgL53F0jwlP8zkYB6Re9W4ev2OmfHtN+fl3xwnxaSmp36u5SAmKZa4My9V26VJGAqd/QMTb0tRLVAHGtrt5NrBkGjfp5SadfjpaXDVsx4/cTL5UycfzTN12fKVFD16WbUowyDDw8sHEjJGp+CKOjMWAAok13vSGKUVNSHGMUUtderR92mi+beqaO5OGHL4oYRqXKXpVB+fG5dYk0e84MkVgslUoZACKxiFWpPc9MPzZ36q2Ox8+MqCZL2tLjyzClHs5GNc87JzxOTti+HSXUzNCckoL+/U1hZFc+TOk7SYrhRT0AievI+XPnzxtU59MMF6LyVSq8fhSeCShenD37WJtbGsrHR3Zffceyydd3/qdo2swu+Z2oUvXyMqiijhy8op/lkmxt9bJbw6tQATt3omLFvFuUSowZg/PnTbAfOCfqGzUlxfJsFBBX7zR+LJBjGQbGrueMATsmte1UuWLFSlaVtJlBSFLbOd3P64sRrzJrjFy//X92osk+/07v1L1q6RJVS9bSzwdburRedmtgVlb45x/Ur692408/YfduqEx9tbbK9ECWCaGnmATl66+xbh3fRXAjk2HtWgwfrnbj2rX49lujW/lUH+bOha8v30UQHSmmZ6NGKDEx8WkeI0aMmD179qdG9vb8FagLEgl++EFThp44kc8izSaFYdT2ZxChohg1NLlc/uLFi1xxGR4enpGRYW9v7/BBu3btHBwcnJ2dP3uxvT1EIqFe8YpE8PbGnDlqN966hUGDkJJi4Jr4IRajQgW+iyC6U7xi1NfXd968efzWIJFIqlSp8jEu+/Tpk/0HOzu7gl9csSLEYkHGKMOgVSts2ACxmm7nly/h7Z3PEvemRixGpUp8F0F0h/pGBeXuXbi5ISOD7zoKr0EDnDiB8uXzbklJQZcupn9rPidra0RFqR3rRQSpeA54EixHR5gLcGXyihWxY4faDFUq8fXXuHChGGUogFq1KENNCsWooJiZoVYtvosopJIlsXkz6tVTu3H2bOzcKcheCi5cXfmugOgUxajQuLjwXUFhmJnBzw/t26vduGYNli83wdmb8scwaNCA7yKITlGMCs3//geRQL5rEglmzcJQ9YvQHTmC774rFsObcpFIkGv8BRE6gfxCko+++ALvH/Q3biIR+vVDzkGvOYSFYcQIpKYauCajYGmJpk35LoLoFMWo0Li6CmBaC4aBpyfWr1c7vOn58+I1vCmXxo3pgXpTQzEqNJaWaNKE7yIK0qAB/v1X7WRwyckYNCifRZhMHMOgTRu+iyC6RjEqQG3bapou3ihUqoTt21FOzepJcjlGjMDFi8VreFNOUinc3fkugugaxagAtWgBmYzvIjSwscG2bZqGN/3wA/btK3bDm3IqVYo6Rk0QxagANWmidig7/8zMsGIFWrVSu9HPD6tWQZnvWqomr0sXmvfeBFGMCpBUCi8vvovIQyLBTz9h2DC1Gw8dwsyZxXF4U05SKbp357sIogcUo8LUubNxDXsSiTB0KGbOVLvx5k2MGlVMhzflZGur6UEEImwUo8Lk6QltZoQyDIZBhw7w81P7XEAxH96U01df0RW9aaIYFaYSJdC7N99FfODigs2b1Y5mffsW/foV3+FNOclkRvQdI7pFMSpYffsaxXrL+Q5vGjkSV68aviZjVKsWXdGbLIpRwfLw4H+2Jxsb7Nih6RHx2bNx4ECxHt70kUiEUaPUPtJFTAHFqGCJRBg9ms9fTTMz/PEHWrZUu3HFCqxcWexmb9KkVCkMGMB3EURvKEaFbOBA3laul0jg64shQ9Ru3L8fs2YV9+FNOfXpo7bbg5gIilEhK10aAwbw8GCoWIzhw/H992o3hoZizBikpxu4JuNlYYGvv+a7CKJPFKMCN2GCodejYBi0bYsVK9TGd2QkvL3x5o1BKzJyffrgiy/4LoLoE8WowNWqBW9vgx7R1RXbtqkdAJmYCG9vPHli0HKMnKUlpk7luwiiZxSjwvftt4Yb1V2tGnbvRtmyebfI5Rg1CiEhBipEKPr0QcOGfBdB9IxiVPhcXDBwoCF6SEuVwtatcHTMu4VlMXUqDW/KrWRJfPcd30UQ/aMYNQmzZqFUKf0ewtwc69ZpGt60dCnWrSvuszflIhLhm280TRlITArFqEmoXh1jx+pxqTupFPPna+qEPXAAc+ZALtfXwQWqcmU6FS0uGLbYTkRuYhIT0bgxwsN1v2exGCNGYN06tf0GV67AywsJCbo/rKBJJNiwQdOsgcTU0NmoqbC1xbx5up89j2HQqRP8/NRm6NOn8PGhDFWjRQsMHsx3EcRQ6GzUhKhU6NoVR4/qcp9ubggMVDspX2IiOnbEtWu6PJppKFUKQUF0g74YobNREyIS4Y8/1I5GKqLq1eHvrzZDs7IwciQNb1JDIsH8+ZShxQvFqGlxdNTZpb2tLbZuRc2aebdkD286eLD4LvCZj/btMW4c30UQw6IYNTljx6JjR67DSC0ssGEDWrRQu/H337F+PQ1vUqN8efj50YR4xQ7FqMkRibBuHWrUKPoepFL8/LOmudr378fcuTS8SQ0LC6xdq/b0nZg4ilFTZG+P9euL+IRo9uxNGp4Dv3wZI0fS7E1qSCSYORM9evBdB+EDxaiJ8vTE7NmQSAr3KoZB166ahjdFRGDgQBrepAbDoHt3zJrFdx2EJzTgyXSpVBg2DNu2FeJB90aNEBiI0qXzbklIQMeOdGtePVdXnDql9mMjxQLFqElLTUXnzrhwQat76jVq4ORJODjk3ZKRgV69cOwY3ZpXw8EBR4+idm2+6yD8oYt6k1aiBPz9tZoeo3Rp7NypNkNZFtOm4fhxylA17O0REEAZWtxRjJo6e3vs3o3q1fNrk32PuXFjtRsXL8aGDTS8SQ1bW2zfDldXvusgfKMYLQbq1sXOnShfXv1WqRSLFqFPH7Ubd+yAry8Nb1LDxgbbt6NVK77rIEaA+kaLjStX0LMnXr/+7ItiMcaPx8qVal9x6RK6dEFioiGqE5bSpbFlC7y8+K6DGAeK0eIkV5KKROjaFbt2wcwsb9vHj9GuHZ4/N2iBglCuHHbvhocH33UQo0ExWsxcu4a+fREZCQDNmuHYMdjY5G0VH4+OHXH9uqGrM37VqmHPHri58V0HMSYUo8XPo0fo0wepqThxQu2teQBff40NG2hhpc8wDBo1wrZtdF+e5EYxWiy9eoU3b/KZzS0xEWPHYt8+KBSGLMt4SSTo1Qvr1ul9ySsiRBSjRD2lEr/8gkWL6Al6mJlh4kT88kuhn60lxQTFKMnPgQMYOxYxMXzXwROGgb09/PzQsyffpRAjRjFKChAZiYkTcfRosbvAl0jQrh1Wr9bUgUzIezT8nhSgWjXs3481a4rX1BvW1vjlFxw+TBlKCkZno0Rbd+9i3DgEB5v4aalUCg8PLFsGFxe+SyECQWejRFv16iEoCNu2oUYNiEzxB0ckQrVqWL0agYGUoaQQ6GyUFFpiIpYuxR9/IDmZ71J0p0QJDB+OuXNRpgzfpRChoRglRXT7Nn75Bfv3C35ElKUl+vTBjBmoX5/vUogwUYwSTu7cwcqV2LEDqal8l1J45ubo0gU//kjLyhNOKEaJDty5gxUrsGcPkpMF8AipSIRSpdC7N8aNowAlOkAxSnQmNha7dmHDBjx4gKwsvqtRRyqFgwMGDcLw4ahUie9qiKmgGCU6plTixAls345jx5CUZBRTPkulsLWFlxf69kWHDvRMJ9ExilGiL+npOH8eBw5g3z7Ex/NwfiqTwcYGHTrgq6/g5QUrK0MXQIoJilGid+npCA7GpUs4exYhIUhLg1yulwXyGAYSCSwt4eaG1q3h7g53d1ha6v5AhOREMUoMKiUFly/j5k3cu4ewMDx5gsxMKJVQKgsdrAwDsRhiMWQyODrC1RX166N+fbi7w9q6EPtZvHjxyJEjy9B4UVJUFKOET2lpePgQ4eGIi0NUFF6/RlQU4uORmYmUFGRlvb/1b2MDqRQlS8LMDLa2sLdHpUqwt0fZsqheHXXrokSJotcwcuRIR0fHmTNn6u5tkeKFYpQUdzdv3uzatWtERIRUKuW7FiJIpvhoNCGF0bBhQwcHhwMHDmhskerf20JcYcSR908YvAsYWEZs5ROQqd3+2diNXdzm3Cz8fC5sfPDKYS2dHGo61qz1hdfkbffSPu0qOeTfDWdj6RTIOFCMEoKJEyf6+fnl04Ap5VT+dkBQCgAkHQ8Ir+xkrvXOGdtuSzaNqlXYUVbKByv7DDzgsOjso/An4XeOznZKfPYOH3bFJof8u/FsjNE/6VBMUIwSgp49e0ZERFzPZylUmVvvFg/2nk4GmxgY8NKzV70PqZjxcNs3bRs2aFC/XrMBq0NTkHZ5dtMmM4NTwb49NemLFgtvZrKJh2aM3PhYASD9/pavW9V3dmno2rj/+kdKgE0O8fNpXKdO3doNOs0+Fp0jFuWX169JHLxsVstyEgBmFb4cO8GrArJ3JU88/KvftQd/j/Bs3eGn41fmNm67MkIFAIobPzXyfP9nYjgUo4RAIpF88803a9as0dxE1qh3q8cBp94mHNv3ut3HFFXe/2PcVge/4Nu374Ssd9o5Zd1js2Y/+nU8PWnu4f2zp4V6r5nR0OzjLpR3lw9frJx+6vatm2EX/uxbWQRF2O9jNpZbfOnBg7AdnsETZx5596Etm3D3blKDRk5qz2EZ264/TGxcd/hfp84c/7mD2+D+qp07HiiBzEtbD9gP8K5Ov9UGRh84IQAwevTogICA2NhYTQ2kX/RuHb53p//emPa96oqzv8a+OXfq5oNd47xat27dedLhpNTYKBUsmsxa3fl0v2Gh/ddMc5F92gEbe/7cu84jOpUXAzCztbVk2NhLl7M6+LS0Y2Dh7NOnesiF+x97UFkALLTp/BQ7+Ay0278tVJ4atPWE06CeFZgifgSkqOixOEIAoEyZMr169dq0aZPGkU9S116tH3aaL5t6po7k4fuvqVjWttuSE36tc8QlVPH376VYWymj4zJYyPIPNRafbf/4F6Z0vXqlVofcV3T/osDfUVHF3oNrtv/3P6fYi00HL7OjFDU4Ohsl5L2JEyeuXr1arnEWAInryPlz588bVEf84StMeQ/PskdW+0dkAVAm3g97mg7Vi62TfmN+On/IO2Tqj6fffjqfZMp5tLI5+texaCWAjPj4VJYp5+4uC9x+PoFF+t3te541bvnpIl7adPTXpbZOXXg2Wg6wmdEX1/odydF3amFhlvIu+f3fGbsuQxqdHP/DjbaD2tETrzygGCXkvQJHPomrdxo/1rNyjl8asfPkLYsq/tO1Xl1np3ptJu9/nhn5z4TfJTNXDnT834w1/W5Om30yic3ReNN3zG9tnJzr128xfl+UChLX6etHxsxo4lizXr+T7n4LvUp+2rXEafKerd3CZ3nUrFa9hnPnX56Uq2nz8ciMTZv+TU4Pb9iw6dSjaQCs2ni3FNv0HNxC+wEERHdo+D0hn+zevXvVqlVnz57lu5BCkt/+2eNryV/nZjqJC25MdI3ORgn5pOCRT8ZHeWdlN9deR5rPGVOXMpQfdDZKyGd++eWXJ0+ebNq0ie9CiGBQjBLymbi4uCpVqmRkZPBdSNHNnTvX19eX7yqKEYpRQgjhhPpGCSGEE4pRQgjhhGKUEEI4oRglhBBOKEYJIYQTilFCCOGEYpQQQjihGCWEEE4oRgkhhBOKUUII4YRilBBCOKEYJYQQTihGCSGEE4pRQgjhhGKUEEI4oRglhBBOKEYJIYQTilFCCOGEYpQQQjihGCWEEE4oRgkhhBOKUUII4YRilBBCOKEYJYQQTihGCSGEE4pRQgjhhGKUEEI4oRglhBBOKEYJIYQTilFCCOGEYpQQQjihGCWEEE4oRgkhhBOKUUII4YRilBBCOKEYJYQQTihGCSGEE4pRQgjhhGKUEEI4oRglhBBOKEYJIYQTilFCCOGEYpQQQjihGCWEEE4oRgkhhBOKUUII4YRilBBCOKEYJYQQTihGCSGEE4pRQgjhhGKUEEI4oRglhBBOKEYJIYST/wO0wwHUkS8a3gAAAABJRU5ErkJggg==" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1661,243 +1661,10 @@ ".suggestion-name {\n", "font-weight: bold;\n", "}\n", - "filterM ∷ Applicative m ⇒ (a → m Bool) → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → Vector a → m (Vector a)
O(n) Drop elements that do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → Bundle v a → Bundle m v a
Yield a monadic stream of elements that satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → Bundle m v a → Bundle m v a
Drop elements which do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → Stream m a → Stream m a
Drop elements which do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ (Monad m, Vector v a) ⇒ (a → m Bool) → v a → m (v a)
O(n) Drop elements that do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ (Monad m, Prim a) ⇒ (a → m Bool) → Vector a → m (Vector a)
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)
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)
O(n) Drop elements that do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → ConduitT a a m ()
Keep only values in the stream passing a given monadic predicate.\n", - "\n", - "Subject to fusion\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → Pipe a a m r
(filterM predicate) only forwards values that satisfy the\n", - "monadic predicate\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)
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]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ (IsSequence seq, Monad m) ⇒ (Element seq → m Bool) → seq → m seq
The monadic version of filter.\n", - "
\n", - "filterM ∷ (Monad m) ⇒ (a → m Bool) → Stream (Of a) m r → Stream (Of a) m r
Skip elements of a stream that fail a monadic test\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ (Monad m, Vector v a) ⇒ a → m Bool → v a → m v a
O(n) Drop elements that do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Monad m ⇒ a → m Bool → Vector a → m Vector a
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
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
O(n) Drop elements that do not satisfy the monadic predicate\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Monad m ⇒ (a → m Bool) → [a] → m [a]
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ (Applicative f) ⇒ (a → f Bool) → [a] → f [a]
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))
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
Same as filter but with a monadic predicate.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n", - "filterM ∷ Applicative m ⇒ a → m Bool → [a] → m [a]
This generalizes the list-based filter function.\n", - "
\n" + "No result: no matching identifiers found.\n" ], "text/plain": [ - "filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]\n", - "URL: https://hackage.haskell.org/package/base/docs/Control-Monad.html#v:filterM\n", - "This generalizes the list-based filter function.\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> Vector a -> m (Vector a)\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector.html#v:filterM\n", - "O(n) Drop elements that do not satisfy the monadic predicate\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> Bundle v a -> Bundle m v a\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Fusion-Bundle.html#v:filterM\n", - "Yield a monadic stream of elements that satisfy the monadic predicate\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Fusion-Bundle-Monadic.html#v:filterM\n", - "Drop elements which do not satisfy the monadic predicate\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Fusion-Stream-Monadic.html#v:filterM\n", - "Drop elements which do not satisfy the monadic predicate\n", - "\n", - "filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Generic.html#v:filterM\n", - "O(n) Drop elements that do not satisfy the monadic predicate\n", - "\n", - "filterM :: (Monad m, Prim a) => (a -> m Bool) -> Vector a -> m (Vector a)\n", - "URL: https://hackage.haskell.org/package/vector/docs/Data-Vector-Primitive.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/vector/docs/Data-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/vector/docs/Data-Vector-Unboxed.html#v:filterM\n", - "O(n) Drop elements that do not satisfy the monadic predicate\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> ConduitT a a m ()\n", - "URL: https://hackage.haskell.org/package/conduit/docs/Data-Conduit-Combinators.html#v:filterM\n", - "Keep only values in the stream passing a given monadic predicate.\n", - "\n", - "Subject to fusion\n", - "\n", - "filterM :: Applicative m => a -> m Bool -> [a] -> m [a]\n", - "URL: https://hackage.haskell.org/package/Cabal/docs/Distribution-Compat-Prelude-Internal.html#v:filterM\n", - "This generalizes the list-based filter function.\n", - "\n", - "filterM :: Monad m => (a -> m Bool) -> Pipe a a m r\n", - "URL: https://hackage.haskell.org/package/pipes/docs/Pipes-Prelude.html#v:filterM\n", - "(filterM predicate) only forwards values that satisfy the\n", - "monadic predicate\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: 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." + "No response available: no matching identifiers found." ] }, "metadata": {}, @@ -2009,7 +1776,7 @@ ".suggestion-name {\n", "font-weight: bold;\n", "}\n", - "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", "\n", "
\n",
        "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
@@ -2030,7 +1797,7 @@
        "zip _|_ [] = _|_\n",
        "
\n", "
\n", - "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", "\n", "
\n",
        "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
@@ -2051,7 +1818,7 @@
        "zip _|_ [] = _|_\n",
        "
\n", "
\n", - "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", "\n", "
\n",
        "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
@@ -2072,7 +1839,7 @@
        "zip _|_ [] = _|_\n",
        "
\n", "
\n", - "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", "\n", "
\n",
        "zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]\n",
@@ -2093,7 +1860,28 @@
        "zip _|_ [] = _|_\n",
        "
\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\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 ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2103,23 +1891,13 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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",
+       "zipExact ∷ Partial ⇒ [a] → [b] → [(a, b)]
\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)]
zip takes two lists and returns a list of corresponding pairs.\n",
+       "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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",
@@ -2129,7 +1907,7 @@
        "zip [] _|_ = []\n",
        "
\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2139,7 +1917,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2149,7 +1927,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2159,7 +1937,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2169,7 +1947,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2179,7 +1957,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2189,20 +1967,20 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ [a] → [b] → [(a, b)]
\n", - "(+*+) ∷ [a] → [b] → [(a, b)]
Slightly unfair 2-way Cartesian product: given two (possibly infinite)\n", + "zip ∷ [a] → [b] → [(a, b)]
\n", + "(+*+) ∷ [a] → [b] → [(a, b)]
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)]
Very unfair 2-way Cartesian product: same guarantee as the slightly\n", + "unfairCartesianProduct ∷ [a] → [b] → [(a, b)]
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)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2212,7 +1990,28 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\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 ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2222,7 +2021,10 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ [a] → [b] → [(a, b)]
\n", + "zip ∷ [a] → [b] → [(a, b)]
\n", + "zip ∷ [a] → [b] → [(a, b)]
\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2232,10 +2034,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ [a] → [b] → [(a, b)]
\n", - "zip ∷ [a] → [b] → [(a, b)]
\n", - "zip ∷ [a] → [b] → [(a, b)]
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2245,7 +2044,28 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\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 ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2255,7 +2075,7 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
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", @@ -2265,58 +2085,49 @@ "zip [] _|_ = []\n", "\n", "
\n", - "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\n", + "zip ∷ () ⇒ [a] → [b] → [(a, b)]
zip takes two lists and returns a list of corresponding pairs.\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", + "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 ∷ () ⇒ [a] → [b] → [(a, b)]
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)]
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)]
zipLazy is a kind of zip that is lazy in the second list\n", + "zipLazy ∷ [a] → [b] → [(a, b)]
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)
Generalized version of concurrently.\n", + "concurrently ∷ MonadBaseControl IO m ⇒ m a → m b → m (a, b)
Generalized version of concurrently.\n", "
\n", - "concurrently ∷ ∀ m a b . (MonadBaseControl IO m, Forall (Pure m)) ⇒ m a → m b → m (a, b)
Generalized version of concurrently.\n", + "concurrently ∷ ∀ m a b . (MonadBaseControl IO m, Forall (Pure m)) ⇒ m a → m b → m (a, b)
Generalized version of concurrently.\n", "
\n", - "pairADefault ∷ Applicative f ⇒ f a → f b → f (a, b)
Default '>*< implementation for non-invertible\n", + "pairADefault ∷ Applicative f ⇒ f a → f b → f (a, b)
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)
O(min(m,n)) Zip two vectors\n", + "zip ∷ (Vector v a, Vector v b, Vector v (a, b)) ⇒ v a → v b → v (a, b)
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)
Pair two samples. It's like zip but requires that both samples\n", + "pair ∷ (Vector v a, Vector v b, Vector v (a, b)) ⇒ v a → v b → v (a, b)
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)
O(min(m,n)) Zip two vectors\n", + "zip ∷ (Vector v a, Vector v b, Vector v (a, b)) ⇒ v a → v b → v (a, b)
O(min(m,n)) Zip two vectors\n", "
\n", - "concurrently ∷ MonadUnliftIO m ⇒ m a → m b → m (a, b)
Unlifted concurrently.\n", + "concurrently ∷ MonadUnliftIO m ⇒ m a → m b → m (a, b)
Unlifted concurrently.\n", "
\n", - "concurrently ∷ MonadUnliftIO m ⇒ m a → m b → m (a, b)
Unlifted concurrently.\n", + "concurrently ∷ MonadUnliftIO m ⇒ m a → m b → m (a, b)
Unlifted concurrently.\n", "
\n", - "zip ∷ Sequence s ⇒ s a → s b → s (a, b)
Combine two sequences into a sequence of pairs. If the sequences are\n", + "zip ∷ Sequence s ⇒ s a → s b → s (a, b)
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", @@ -2335,9 +2146,9 @@ "\n", "Default running time: O( min( n1, n2 ) )\n", "
\n", - "zipUsingLview ∷ Sequence s ⇒ s a → s b → s (a, b)
\n", - "zipUsingLists ∷ Sequence s ⇒ s a → s b → s (a, b)
\n", - "concurrently ∷ MonadConc m ⇒ m a → m b → m (a, b)
Run two MonadConc actions concurrently, and return both\n", + "zipUsingLview ∷ Sequence s ⇒ s a → s b → s (a, b)
\n", + "zipUsingLists ∷ Sequence s ⇒ s a → s b → s (a, b)
\n", + "concurrently ∷ MonadConc m ⇒ m a → m b → m (a, b)
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", @@ -2349,8 +2160,8 @@ "waitBoth a b\n", "\n", "
\n", - "mzipRep ∷ Representable f ⇒ f a → f b → f (a, b)
\n", - "box ∷ Graph g ⇒ g a → g b → g (a, b)
Compute the Cartesian product of graphs. Complexity: O(s1 *\n", + "mzipRep ∷ Representable f ⇒ f a → f b → f (a, b)
\n", + "box ∷ Graph g ⇒ g a → g b → g (a, b)
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", @@ -2378,11 +2189,11 @@ "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",
+       "divided ∷ Divisible f ⇒ f a → f b → f (a, b)
\n",
        "divided = divide id\n",
        "
\n",
        "
\n",
-       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
The RecordInputType divisible (contravariant) functor allows\n",
+       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
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",
@@ -2443,19 +2254,19 @@
        "\n",
        "Infix divided\n",
        "
\n",
-       "divided ∷ Divisible f ⇒ f a → f b → f (a, b)
\n",
+       "divided ∷ Divisible f ⇒ f a → f b → f (a, b)
\n",
        "divided = divide id\n",
        "
\n",
        "
\n",
-       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
An alias to divided.\n",
+       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
An alias to divided.\n",
        "
\n",
-       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
An alias to divided.\n",
+       "(>*<) ∷ Divisible f ⇒ f a → f b → f (a, b)
An alias to divided.\n",
        "
\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",
+       "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",
-       "(>*<) ∷ Monoidal f ⇒ f a → f b → f (a, b)
A pairing/concatenation operator for builder primitives, both bounded\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",
@@ -2471,35 +2282,35 @@
        "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",
+       "(>*<) ∷ 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",
+       "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)
Binary operator the same as projectZip.\n",
+       "(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Binary operator the same as projectZip.\n",
        "
\n",
-       "projectZip ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Zipping projections.\n",
+       "projectZip ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Zipping projections.\n",
        "
\n",
-       "(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Binary operator the same as projectZip.\n",
+       "(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Binary operator the same as projectZip.\n",
        "
\n",
-       "(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Binary operator the same as projectZip.\n",
+       "(><) ∷ ProductIsoApplicative p ⇒ p a → p b → p (a, b)
Binary operator the same as projectZip.\n",
        "
\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",
+       "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",
+       "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",
+       "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",
@@ -2512,7 +2323,7 @@
        ", ((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", + "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", @@ -2525,10 +2336,10 @@ ", ((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" + "zipExactMay ∷ [a] → [b] → Maybe [(a, b)]
\n" ], "text/plain": [ - "zip :: [a] -> [b] -> [(a, b)]\n", + "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", @@ -2551,7 +2362,7 @@ "zip _|_ [] = _|_\n", "\n", "\n", - "zip :: [a] -> [b] -> [(a, b)]\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", @@ -2574,7 +2385,7 @@ "zip _|_ [] = _|_\n", "\n", "\n", - "zip :: [a] -> [b] -> [(a, b)]\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", @@ -2597,7 +2408,7 @@ "zip _|_ [] = _|_\n", "\n", "\n", - "zip :: [a] -> [b] -> [(a, b)]\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", @@ -2620,19 +2431,30 @@ "zip _|_ [] = _|_\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\n", + "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", + "\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", + "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 :: () => [a] -> [b] -> [(a, b)]\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", @@ -2644,7 +2466,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zipExact :: Partial => [a] -> [b] -> [(a, b)]\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",
@@ -2652,7 +2474,7 @@
        "| otherwise              = error \"some message\"\n",
        "
\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2664,7 +2486,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2676,7 +2498,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2688,7 +2510,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2700,7 +2522,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2712,7 +2534,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2724,7 +2546,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2736,10 +2558,10 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: [a] -> [b] -> [(a, b)]\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", + "(+*+) :: [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", @@ -2748,14 +2570,14 @@ "fst part of the tuple more frequently, but not exponentially\n", "so.\n", "\n", - "unfairCartesianProduct :: [a] -> [b] -> [(a, b)]\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", + "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", @@ -2767,19 +2589,30 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", + "\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", + "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 :: () => [a] -> [b] -> [(a, b)]\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", @@ -2791,16 +2624,16 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: [a] -> [b] -> [(a, b)]\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", + "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", + "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", + "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", @@ -2812,7 +2645,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2824,19 +2657,30 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", + "\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", + "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 :: () => [a] -> [b] -> [(a, b)]\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", @@ -2848,7 +2692,7 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", @@ -2860,58 +2704,69 @@ "zip [] _|_ = []\n", "\n", "\n", - "zip :: () => [a] -> [b] -> [(a, b)]\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", + "\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", + "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", - "zipLazy :: [a] -> [b] -> [(a, b)]\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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", @@ -2932,13 +2787,13 @@ "\n", "Default running time: O( min( n1, n2 ) )\n", "\n", - "zipUsingLview :: Sequence s => s a -> s b -> s (a, b)\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", + "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", + "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", @@ -2952,10 +2807,10 @@ "waitBoth a b\n", "\n", "\n", - "mzipRep :: Representable f => f a -> f b -> f (a, b)\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", + "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", @@ -2985,13 +2840,13 @@ "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", + "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", + "(>*<) :: 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", @@ -3054,31 +2909,31 @@ "\n", "Infix divided\n", "\n", - "divided :: Divisible f => f a -> f b -> f (a, b)\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", + "(>*<) :: 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", + "(>*<) :: 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", + "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", + "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", + "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", + "(>*<) :: 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", @@ -3096,69 +2951,69 @@ "toLazyByteString (primFixed (char7 >*< char7 >*< char7) ('x',('y','z'))) = \"xyz\"\n", "\n", "\n", - "(>*<) :: Monoidal f => f a -> f b -> f (a, b)\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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "(><) :: 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", + "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", + "(><) :: 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", + "(><) :: 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", + "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", + "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", + "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", + "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", + "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", + "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", @@ -3173,7 +3028,7 @@ ", ((2,'a'),(3,'a')), ((2,'b'),(3,'b')), ((3,'a'),(3,'b')) ]\n", "\n", "\n", - "torus :: Graph g => [a] -> [b] -> g (a, b)\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", @@ -3188,7 +3043,7 @@ ", ((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", + "zipExactMay :: [a] -> [b] -> Maybe [(a, b)]\n", "URL: https://hackage.haskell.org/package/safe/docs/Safe-Exact.html#v:zipExactMay" ] },