Search results

Page title matches

• Es/Librerias y Herramientas/Estructuras de Datos
  {{Es/Traducción en progreso|titulo=Librerias y Herramientas/Estructuras de Datos}} == Librerias y herramientas para Estructuras de datos en Haskell ==
  10 KB (1,459 words) - 19:29, 15 August 2019

Page text matches

• Unix tools/yes
  A simple utility to repeatedly print <code>"y"</code> to standard output. main = let y = putStrLn "y" >> y in y
  472 bytes (67 words) - 03:24, 26 April 2021
• 99 questions/Solutions/14
  and here is the proof that <hask>((.) <$> (:) <*> (:)) = (\y z -> y:y:z)</hask>: \y -> (\x -> (.) (x:)) y (y:) = -- definition of (<*>) for functions
  2 KB (220 words) - 20:45, 28 December 2014
• 99 questions/Solutions/32
  gcd' 0 y = y gcd' x y = gcd' (y `mod` x) x
  777 bytes (117 words) - 19:42, 18 January 2014
• Floyd's cycle-finding algorithm
  where fCycle (x:xs) (_:y:ys) | x == y = fStart xxs xs
  950 bytes (133 words) - 00:39, 5 February 2019
• Uniplate
  variables (Add x y) = variables x ++ variables y variables (Sub x y) = variables x ++ variables y
  2 KB (315 words) - 08:34, 12 May 2016
• Nhc98
  uncommon x y=common (finalsort (x++y)) common (x:y:zs)
  857 bytes (148 words) - 04:14, 18 June 2021
• RodinV08-Package1
  { fie y 2; fie x x-(fie y 1);
  3 KB (276 words) - 15:17, 6 February 2021
• 99 questions/Solutions/9
  getReps (y:ys) | y == x = let (f,r) = getReps ys in (y:f, r)
  2 KB (347 words) - 21:03, 20 December 2018
• Infix expressions
  data Infix f y = f :- y x -:f:- y = x `f` y
  2 KB (240 words) - 23:49, 18 April 2021
• Ternary operator
  Prelude.False ? (_ : y) = y False ? (_ :? y) = y
  847 bytes (121 words) - 23:08, 24 July 2021
• Idiom brackets
  f <$> x <*> y Since f is not a pure function, it's f :: x -> y -> m c. The correct form would be
  2 KB (365 words) - 18:50, 19 September 2017
• 99 questions/Solutions/91
  knightMoves n (x, y) = filter (onBoard n) [(x+2, y+1), (x+2, y-1), (x+1, y+2), (x+1, y-2),
  3 KB (449 words) - 03:45, 10 January 2017
• Untypeable Haskell 98
  g y = bind x y g y = bind x y
  772 bytes (147 words) - 15:19, 6 February 2021
• 99 questions/Solutions/57
  add x t@(Branch y l r) = case compare x y of LT -> Branch y (add x l) r
  741 bytes (117 words) - 22:03, 23 April 2021
• 99 questions/Solutions/65
  layoutAux x y sep Empty = Empty layoutAux x y sep (Branch a l r) =
  2 KB (299 words) - 03:42, 10 January 2017
• 99 questions/Solutions/89
  adjacent = [x | (x,y)<-e,y==nv] ++ [x | (y,x)<-e,y==nv] adjacent = [x | (x,y)<-e,y==nv] ++ [x | (y,x)<-e,y==nv]
  1 KB (163 words) - 03:51, 10 January 2017
• 99 questions/Solutions/64
  * y(v) is equal to the depth of the node v in the tree where layoutAux x y Empty = (Empty, x)
  2 KB (337 words) - 03:41, 10 January 2017
• 99 questions/Solutions/40
  filter (\(x,y) -> isPrime x && isPrime y) $ goldbach n = head [(x,y) | x <- pr, y <- pr, x+y==n]
  1 KB (226 words) - 19:47, 18 January 2014
• 99 questions/Solutions/13
  helper x (y@(a,b):ys) | otherwise = (1,x):y:ys
  3 KB (381 words) - 02:13, 5 March 2019
• IO入門編
  .../code>がIOアクションなら、<code>(x >> y)</code>は<code>x</code>を実行し、結果を破棄し、そのあと<code>y</code>を実行してその結果を返します。 x >> y = x >>= const y
  7 KB (299 words) - 11:39, 22 October 2022
• Quicksort
  quick (h:t)= quick [ y | y <- t , y < h] ++ [h] ++ quick [ y | y <- t , y > h] * { y | y ← t , y < h }
  1 KB (213 words) - 21:55, 5 April 2021
• Beta reduction
  (\x -> 2*x*x + y) (\x -> 2*x*x + y)(7)
  878 bytes (133 words) - 16:57, 6 February 2016
• 99 questions/Solutions/66
  layoutAux x y Empty = ([], Empty, []) layoutAux x y (Branch a l r) = (ll', Branch (a, (x,y)) l' r', rr')
  4 KB (637 words) - 03:42, 10 January 2017
• Haskell Quiz/Bytecode Compiler/Solution Pepe Iborra
  generate (x :+ y) = binaryOp x y add generate (x :- y) = binaryOp x y sub
  3 KB (386 words) - 21:41, 23 April 2021
• Partial application
  Partial application in Haskell involves passing less than the full number of arguments to a function that takes multiple argumen add x y = x + y
  1 KB (248 words) - 20:05, 13 May 2020
• Unix tools/Date
  $ ./a.out "%a %b %e %H:%M:%S %Z %Y" $ ./a.out "%y-%m-%d"
  543 bytes (78 words) - 15:19, 6 February 2021
• 99 questions/Solutions/22
  range x y = [x..y] range x y = take (y-x+1) $ iterate (+1) x
  1 KB (214 words) - 02:08, 5 April 2014
• 99 questions/Solutions/87
  adjacent = [x | (x,y)<-e,y==top] ++ [x | (y,x)<-e,y==top]
  714 bytes (91 words) - 03:50, 10 January 2017
• Closure
  f x = (\y -> x + y)
  566 bytes (92 words) - 13:53, 1 January 2017
• 99 questions/Solutions/88
  adjacent = [x | (x,y)<-e,y==top] ++ [x | (y,x)<-e,y==top]
  1 KB (123 words) - 03:51, 10 January 2017
• Import
  ...module <hask>Mod</hask> exports four functions named <hask>x</hask>, <hask>y</hask>, <hask>z</hask>, and <hask>(+++)</hask>... | <hask>x, y, z, (+++), Mod.x, Mod.y, Mod.z, (Mod.+++)</hask>
  4 KB (659 words) - 10:27, 14 January 2024
• 99 questions/Solutions/82
  ...go ls = [ x ++ [snd y] | x <- ls, y <- g, last x == fst y, not (snd y `elem` tail x)]
  1 KB (153 words) - 06:29, 31 July 2021
• Avoiding partial functions
  y:ys -> h y ys y:ys -> uncurry h $ viewRTotal y ys
  3 KB (506 words) - 04:03, 4 September 2017
• 99 questions/Solutions/67A
  tfs (x:y:xs) | y == ',' || y == ')' = return (y:xs, Branch x Empty Empty)
  2 KB (372 words) - 03:43, 10 January 2017
• The Monad.Reader/Discuss Issue11/FingerTreeIMap
  (Key _ x) `mappend` (Key k y) = Key k (x `mappend` y) measure (Elem x y) = Key x y
  2 KB (315 words) - 15:19, 6 February 2021
• 99 questions/Solutions/84
  edgeIn g (x,y) = elem y (adjacent g x) weight x y g = head [c | (a,c) <- g!x, a == y]
  1 KB (189 words) - 03:50, 10 January 2017
• OCaml
  \x y -> ... fun x y -> ...
  2 KB (293 words) - 16:34, 15 May 2023
• Graham Scan Implementation
  polar (x, y) = atan2 (y - y0) (x - x0) grahamScan' xs [y] = y : xs
  2 KB (298 words) - 03:42, 14 August 2021
• Instances of List and Maybe
  > mul xs ys = do x<-xs; y<-ys; return (x*y) > mul x' y' = do x<-x'; y<-y' return (x*y)
  3 KB (320 words) - 15:53, 21 June 2018
• Partible laws
  !y -> h y u2 !y -> h y u2
  13 KB (2,108 words) - 12:52, 1 January 2024
• Anonymous function
  Or I could make a nameless function of two parameters, x and y: <hask>\x y -> x + y</hask>, which could be applied like so:
  2 KB (296 words) - 06:56, 12 April 2021
• 99 questions/Solutions/36
  where swap (x,y) = (y,x)
  722 bytes (109 words) - 19:45, 18 January 2014
• Ko/Either
  safeDiv x y = Right (x `div` y)
  877 bytes (61 words) - 02:13, 14 November 2023
• New monads/MonadExit
  y <- x case y of
  4 KB (707 words) - 09:43, 9 December 2014
• Let vs. Where
  f x = y where y = ... x ...
  4 KB (716 words) - 07:41, 26 January 2019
• Rubiks Cube
  ...gy to the "right hand rule" convention which assigns an ordering to the "x y and z" axes and determines that z will be "out of" rather than "into" the p The mid points of the 27 small cubes are (x,y,z) where x,y,z ∈ {-10,0,10}.
  8 KB (1,020 words) - 01:02, 23 September 2018
• Bowling
  scoreFrame (x:y:rest) | x+y < 10 = (x+y,rest) addFrame (total,x:y:rest) | x+y < 10 = (total+x+y ,rest)
  4 KB (555 words) - 15:19, 6 February 2021
• Dynamic programming example
  ...k> if i pieces can be bought, and moreover it can be done by x boxes of 6, y boxes of 9, and z boxes of 20. Below the code for <hask>buy</hask> is more Just(x,y,z) -> Just(x+1,y,z)
  6 KB (929 words) - 06:42, 21 November 2020
• 99 questions/Solutions/49
  gray' n = (gl . gr) [] where gl y = foldr (\s acc -> ('0':s):acc) y gp gr y = foldl (\acc s -> ('1':s):acc) y gp
  2 KB (298 words) - 03:02, 7 June 2021
• Seq
  let y = sum [0..47] in x `seq` 3 + y + y^2
  4 KB (716 words) - 14:44, 8 January 2024
• Partibles for composing monads
  let !y = k x u2 in y
  4 KB (691 words) - 08:14, 12 June 2023
• DDC/DestructiveUpdate
  ...ple point type as an example. In this definition, <hask>x</hask> and <hask>y</hask> are field names and are ''local'' to the <hask>Point</hask> type. Th = Point { x :: Float; y :: Float; }
  3 KB (430 words) - 00:46, 24 February 2018
• Es/Haskell
  ...opilar información en español acerca de este lenguaje puramente funcional, y de esa forma promover su uso entre hispano-hablantes. * [[Librerías y Herramientas|Librerías y Herramientas]]
  6 KB (938 words) - 09:51, 18 July 2017
• Sistemul de inferente de tipuri stabileste singur tipul oricarei expresii ?
  :<code>(\ x -> x x) (\ y -> y)</code> :<code>(\y -> y) (\y -> y)</code>
  4 KB (617 words) - 03:01, 9 April 2021
• 99 questions/Solutions/56
  mirror (Branch _ a b) (Branch _ x y) = mirror a y && mirror b x
  1 KB (179 words) - 13:36, 25 December 2016
• Comparison chain
  lift f x (y,chain) = (x, (f,y):chain) lift f (Just x) y | f x y = Just y
  3 KB (543 words) - 23:08, 26 January 2016
• 99 questions/Solutions/19
  rotate x y | y > 0 = rotate (tail x ++ [head x]) (y-1)
  3 KB (474 words) - 20:35, 23 May 2021
• DDC/FieldProjections
  = Vector { x :: Float; y :: Float; } out vec.y -- prints '4.0'
  3 KB (430 words) - 11:59, 19 April 2021
• 99 questions/Solutions/46
  ...y f domain = concatMap (++ "\n") [printBinaryInstance f x y | x <- domain, y <- domain] printBinaryInstance f x y = show x ++ " " ++ show y ++ " " ++ show (f x y)
  4 KB (655 words) - 07:48, 27 April 2016
• Bresenham's line drawing algorithm
  maySwitch = if steep then (\(x,y) -> (y,x)) else id
  1 KB (168 words) - 23:01, 11 July 2021
• 99 questions/Solutions/41
  goldbachList' n m i = filter (\(x,y) -> x > i && y > i) $ goldbachList n m
  992 bytes (161 words) - 19:48, 18 January 2014
• QuickCheck / GADT
  compress (RPair s t) (x,y) = compress s x ++ compress t y y <- bar t
  8 KB (1,072 words) - 18:32, 16 January 2017
• Ko/PatternSynonyms
  pattern Snd y <- (x, y)
  2 KB (138 words) - 12:11, 22 November 2023
• Monad laws
  |<haskell>(m >>= (\x -> g x)) >>= (\y -> h y)</haskell> |<haskell> m >>= (\x -> g x >>= (\y -> h y))</haskell>
  5 KB (788 words) - 10:40, 1 February 2024
• 99 questions/Solutions/96
  loop (y:ys) | y == '-' = (not . null) ys && isAlphaNum (head ys) && loop (tail ys) | isAlphaNum y = loop ys
  2 KB (346 words) - 03:47, 10 January 2017
• 99 questions/Solutions/31
  union (x:xs) (y:ys) = case (compare x y) of LT -> x : union xs (y:ys)
  3 KB (432 words) - 07:06, 11 May 2016
• 99 questions/Solutions/93
  apply Plus x y = Just (x + y) apply Minus x y = Just (x - y)
  5 KB (621 words) - 15:30, 8 June 2017
• Xmonad/Notable changes since 0.11
  | updatePointer (Relative x y) || updatePointer (x,y) (1,1) | updatePointer (TowardsCentre x y) || updatePointer (0.5,0.5) (x,y)
  3 KB (495 words) - 23:20, 27 June 2016
• Google Code Jam/The Price is Wrong
  parsePrices [x,y] = zip (words x) (map read. words $ y)
  1 KB (177 words) - 22:56, 5 April 2021
• Converting numbers
  coord1ToCoord2 (x, y) = (x/500, (500-y)/500) coord2ToCoord1 (x, y) = (500/(1/x), 500 - 500/(1/y))
  6 KB (867 words) - 01:28, 14 April 2016
• 99 questions/Solutions/11
  encodeModified xs = [y | x <- group xs, let y = if (length x) == 1 then Single (head x) else Multiple (length x) (head x)
  1 KB (196 words) - 19:31, 18 January 2014
• Currying
  f x y = g (x,y) ...ngly, associates ''to the left'': <hask>f x y</hask> is really <hask>(f x) y</hask>, so the types fit. <br><br>
  4 KB (669 words) - 02:17, 3 November 2023
• 99 questions/Solutions/85
  ...at for any nodes X,Y of N1, X and Y are adjacent if and only if f(X) and f(Y) are adjacent.
  2 KB (287 words) - 03:50, 10 January 2017
• Infix operator
  Prelude> let concatPrint x y = putStrLn $ (++) x y
  1 KB (159 words) - 23:45, 25 June 2021
• Data declaration with constraint
  add (Cons x) (Cons y) = Cons (x+y) -- requires Num constraint on type a
  2 KB (312 words) - 23:26, 19 September 2016
• 99 questions/Solutions/83
  ...connected (Graph (x':xs') ys') = not $ any (null) [paths' x' y' ys' | y' <- xs']
  2 KB (281 words) - 03:49, 10 January 2017
• Monoid
  (x <> y) <> z = x <> (y <> z) ...namely all the elements of <hask>x</hask>, then all the elements of <hask>y</hask>, them all the elements of <hask>z</hask>.
  7 KB (1,101 words) - 02:30, 27 December 2019
• Context alias
  The current ''Num'' class in the Prelude is (more or less) this Z + y = y
  9 KB (1,395 words) - 23:16, 24 July 2021
• Monad/ST
  y <- newSTRef 1 fibST' n x y
  5 KB (802 words) - 05:38, 4 August 2021
• 99 questions/Solutions/10
  encode' n x (y:ys) | x == y = encode' (n + 1) x ys
  3 KB (470 words) - 03:45, 19 May 2021
• Type SK
  > data App x y > class Eval1 x y d | x -> y d
  10 KB (1,653 words) - 00:25, 12 July 2021
• List comprehension
  [[[ poly x y | i <- [0..], let x = m + 60*i, test x y ]
  5 KB (679 words) - 17:14, 4 February 2023
• Lifting
  fmap f (Pair x y) = Pair (f x) (f y) liftL2 f x y = fmap (uncurry f) $ zipL x y
  7 KB (1,165 words) - 20:40, 31 October 2019
• Worker wrapper
  ...orker x y</hask> is equivalent to, but probably faster than, <hask>reverse y ++ x</hask>.
  2 KB (333 words) - 12:44, 4 June 2018
• New monads/MonadRandom
  getRandomR (x,y) = RandT $ liftState $ randomR (x,y) getRandomRs (x,y) = RandT $ liftState $
  6 KB (894 words) - 13:41, 2 April 2019
• Euler problems/21 to 30
  y = div n m x = xs!!y
  8 KB (1,054 words) - 15:53, 11 October 2015
• Applicative functor
  An applicative functor has more structure than a [[functor]] but less than a [[monad]]. See the Haddock docs for [https://hackage.haskell.org/pa g :: x -> y
  8 KB (1,326 words) - 08:20, 31 March 2022
• Concurrency demos/Zeta
  zetaRange s (x,y) = [ fromIntegral n ** (-s) | n <- [x..y] ] cut (x,y) n = (x, x + mine - 1) : cut' (x + mine) size (y - mine)
  4 KB (555 words) - 10:58, 22 June 2021
• Haskell Quiz/Sokoban/Solution Jethr0
  show steps : [[charRep (x,y) | x <- [0..maxX]] | y <- [0..maxY]] where cells = map (\(y,xs) -> zipWith (\x c -> ((x,y),c)) [0..] xs)
  4 KB (516 words) - 15:19, 6 February 2021
• Foldl as foldr alternative
  ...by the <hask>construct</hask> here, calling this e.g. for a list <hask>[x,y,...,z]</hask> scans through the whole list as-if evaluating a nested lambda (f acc y))
  5 KB (891 words) - 14:21, 3 January 2018
• Do notation considered harmful
  y <- Just (5*7) return (x-y)
  10 KB (1,589 words) - 01:08, 27 September 2021
• 99 questions/Solutions/16
  divides x y = y `mod` x == 0
  4 KB (546 words) - 19:18, 31 August 2016
• Euler problems/61 to 70
  diff (x:y:xs) = if fst x /= fst y then diff (y:xs) else False problem_63=length[x^y|x<-[1..9],y<-[1..22],y==(length$show$x^y)]
  6 KB (979 words) - 10:20, 18 May 2022
• Prelude extensions
  class Pair p x y | p -> x, p -> y where toPair :: p -> (x, y)
  4 KB (684 words) - 02:22, 18 May 2020
• Euler problems/1 to 10
  f x y | fst z <= n2 = z | otherwise = y
  6 KB (881 words) - 02:31, 8 May 2016
• Generalised algebraic datatype
  <math>\lambda\;x\;y\;.\;x</math> <math>\lambda\;x\;y\;z\;.\;x\;z\;(\;y\;z\;)</math>
  8 KB (1,374 words) - 14:33, 15 December 2022
• Clase de tipuri
  x <= y = compare x y /= GT x < y = compare x y == LT
  4 KB (572 words) - 10:25, 9 October 2019
• 99 questions/Solutions/12
  decodeModified = foldl (\x y -> x ++ decodeHelper y) []
  2 KB (362 words) - 17:33, 13 June 2020
• If-then-else
  if' False _ y = y flipCond cond (x,y) | cond = (x,y)
  6 KB (937 words) - 05:34, 10 December 2020
• Testing primality
  f x n y | n == 1 = x `mul` y
  4 KB (605 words) - 17:09, 18 July 2022
• A new list type
  zipWith f (Node n0 x xs) (Node n1 y ys) = Node (n0 `min` n1) (f x y) (zipWith f xs ys) zip = zipWith (\x y -> (x,y))
  3 KB (587 words) - 15:19, 6 February 2021
• 99 questions/Solutions/81
  paths1 a b g current = paths2 a b g current [ y | (x,y) <- g, x == a ]
  2 KB (359 words) - 20:50, 30 July 2021
• Category theory/Natural transformation
  ...athbf{Ob}(\mathcal C)</math>. Let <math>f \in \mathrm{Hom}_{\mathcal C}(X, Y)</math>. ==== Right: side of ''Y'' object ====
  9 KB (1,305 words) - 03:17, 23 September 2014
• Tiny Identifier Dictionary
  | x,y,z | x,y,z
  2 KB (285 words) - 01:34, 14 July 2021
• 99 questions/Solutions/26
  combinations n xs = [ y:ys | y:xs' <- tails xs combinations n xs = do y:xs' <- tails xs
  5 KB (659 words) - 19:40, 18 January 2014
• 99 questions/Solutions/8
  compress (x:ys@(y:_)) | x == y = compress ys
  3 KB (454 words) - 15:07, 2 October 2020
• LensBeginnersCheatsheet
  ...ment with a more specific and less esoteric type than the more general and less foo_barL = lens _bar (\x y -> x { _bar = y })
  5 KB (742 words) - 19:22, 22 May 2022
• 99 questions/Solutions/21
  insertAt x (y:ys) n = y:insertAt x ys (n-1)
  2 KB (354 words) - 14:31, 5 January 2024
• MonadFix
  Node y _ <- readIORef q print y
  10 KB (1,757 words) - 23:34, 24 July 2021
• 99 questions/Solutions/50
  ...t (x,y,_) = L.sortBy (\(a,b) (x,y) -> compare (length b) (length y)) $ zip y x ...ombine_elements (a,b,c) (x,y,z) = ( (map ('0':) a) ++ (map ('1':) x), b ++ y, c+z)
  5 KB (738 words) - 19:53, 18 January 2014
• Output/Input
  let !y = k x u2 in y
  8 KB (1,236 words) - 12:36, 1 January 2024
• Reference card
  [ (x, y) | x <- [1..3], y <- "ab"] ==> [ (x,y) | x <- [1..4], even x, y <- "ab" ] ==>
  4 KB (584 words) - 13:24, 22 April 2021
• Case comprehensions
  concatMap f xs = [ x <- xs, y <- f x -> y ] concatMap f xs = [ y | x <- xs, y <- f x ]
  6 KB (743 words) - 02:12, 5 August 2021
• 99 questions/Solutions/17
  second (_, y, _) = y
  3 KB (452 words) - 21:07, 10 March 2019
• Scoped type variables
  It is used like <hask>x `asTypeOf` y</hask> and has the same value like <hask>x</hask>, but type inference asserts that <hask>x</hask> and <hask>y</hask> have the same type.
  3 KB (435 words) - 22:56, 12 June 2021
• 99 questions/Solutions/92
  let dists = sort $ map (\(x,y) -> abs (nodeArray ! x - nodeArray ! y)) edges
  3 KB (420 words) - 22:52, 7 June 2017
• Euler problems/11 to 20
  g x y = if snd x < snd y then y else x if y <= n then 1 + a ! y else 1 + syr y
  8 KB (1,028 words) - 15:16, 16 September 2015
• What a Monad is not
  y = b in f x y
  6 KB (1,032 words) - 16:45, 2 December 2020
• Introduction to IO
  where if <code>x</code> and <code>y</code> are IO actions, then <code>(x >> y)</code> is the action that performs <code>x</code>, dropping the result, then performs <code>y</code> and returns its
  5 KB (958 words) - 15:20, 3 August 2022
• Functional programming/Old version
  move y,d1 let s = z-(x+y)
  2 KB (378 words) - 23:58, 5 April 2021
• Case
  if' False _ y = y
  3 KB (411 words) - 11:36, 11 June 2020
• Xmonad/Config archive/thoughtpolice's xmobarrc
  , Run Date "%a %b %_d %Y %H:%M:%S" "date" 10
  1,023 bytes (104 words) - 15:18, 6 February 2021
• AI/Genetic programming/GPLib
  S = \x y z -> ((x z) (y z)) K = \x y -> x
  5 KB (664 words) - 05:48, 12 July 2021
• Foldl as foldr
  mappend (Update x) (Update y) = Update (y.x) mappend (UpdateMaybe x) (UpdateMaybe y) = UpdateMaybe (x>=>y)
  5 KB (822 words) - 10:42, 2 February 2018
• Performance/Data types
  f (x,y) = ... f z = case z of (x,y) -> f' x y
  5 KB (782 words) - 16:41, 4 February 2023
• WxHaskell/Development/Release procedure
  wxhaskell-x-y-z-w
  1 KB (187 words) - 13:26, 30 December 2015
• Functional programming/Alternative 1
  subtractFromList l y = map (\x -> x - y) l ...losure because <hask>\x -> x - y</hask> references a local variable (<hask>y</hask>) from the outside of its body.
  7 KB (1,116 words) - 13:17, 1 October 2021
• Template haskell/Instance deriving example
  where toL (x:y) = (toLower x):y unCapalize (x:y) = (toLower x):y
  6 KB (836 words) - 19:46, 28 December 2013
• Research papers/Authors
  ==Y==
  8 KB (1,251 words) - 05:43, 1 September 2022
• CTRex
  ...ls (except for duplicate labels) does not matter. I.e. {x = 0, y = 0} and {y = 0, x = 0} have the '''same type'''. <haskell> data HRec = HRec { x :: Int, y :: Bool, z :: String } </haskell>
  25 KB (4,073 words) - 08:53, 9 December 2013
• 99 questions/90 to 94
  ...relation jump(N,X/Y,U/V) to express the fact that a knight can jump from X/Y to U/V on a NxN chessboard. And finally, represent the solution of our prob
  6 KB (802 words) - 06:27, 11 June 2023
• Existential type
  data Worker x y = Worker {buffer :: b, input :: x, output :: y} data Worker b x y = Worker {buffer :: b, input :: x, output :: y}
  13 KB (2,093 words) - 10:57, 25 October 2023
• Euler problems/31 to 40
  combs n xs = [(y:ys,rest) | y <- xs, (ys,rest) <- combs (n-1) (delete y xs)] (10x + y)/(10y+z) = x/z
  11 KB (1,557 words) - 09:03, 19 September 2014
• 99 questions/61 to 69
  * In level H, which may contain less than the maximum possible number of nodes, all the nodes are "left-adjusted * y(v) is equal to the depth of the node v in the tree
  12 KB (1,696 words) - 05:35, 11 June 2023
• Untypechecking
  * Next message: [Haskell] Re: Type of y f = f . f \y -> y (\d h p -> d p (h p)) (\d h p -> d)
  20 KB (3,458 words) - 15:19, 6 February 2021
• Aprende Haskell en 10 minutos
  para [[GNU/Linux]], [[BSD | FreeBSD]], [[Mac OS x|MacOS]], [[Windows]], y interés ahora: <tt>ghc</tt>, y <tt>[[GHC/GHCi | ghci]]</tt>. El primero compila
  14 KB (2,164 words) - 16:35, 9 October 2016
• Cum se scrie functia main ?
  y <- readLn ; z <- return (x+y) ;
  3 KB (436 words) - 10:21, 29 November 2019
• GLFW
  (GL.Position x y) <- GL.get GLFW.mousePos modifyIORef lines (((x,y):) . ((x,y):))
  10 KB (1,537 words) - 21:44, 2 October 2014
• Quasiquotation
  write [expr|$x + $int:y|] where x and y are in-scope variables with types Expr eval (BinopExpr op x y) = (opToFun op) (eval x) (eval y)
  12 KB (1,695 words) - 15:27, 12 November 2019
• Section of an infix operator
  ...sk> is the "is-capital-vowel-in-English" function (ignoring the "sometimes Y").
  2 KB (233 words) - 17:58, 31 March 2017
• Inlining and Specialisation
  foo x y = show x == show y</pre> <pre class="haskell">foo = \ @a $dShow x y -&gt;
  13 KB (2,038 words) - 10:49, 22 March 2017
• Curry-Howard-Lambek correspondence
  ...to this category): <math>\mathrm{Hom}(X\times Y,Z) \cong \mathrm{Hom}(X,Z^Y)</math>. ...of type <math>Y \rightarrow Z</math>, that is, a function that takes <math>Y</math> to give (finally) a result of type <math>Z</math>: this technique is
  8 KB (1,303 words) - 15:42, 18 November 2019
• Multiplate
  exprConst (Add (Con x) (Con y)) = return (Con (x + y)) exprConst (Mul (Con x) (Con y)) = return (Con (x * y))
  7 KB (1,049 words) - 07:41, 3 March 2022
• Functional programming
  subtractFromList l y = map (\x -> x - y) l ...osure]] because <hask>\x -> x - y</hask> references a local variable <hask>y</hask> from outside its body.
  9 KB (1,323 words) - 22:19, 10 May 2024
• Common Misunderstandings
  x = b ? y : z; ...-then-else block. It states that if <code>b</code> is true then <code>x = y</code> otherwise <code>x = z</code>. Notice how this makes no sense withou
  11 KB (1,668 words) - 15:16, 4 August 2019
• Cookbook/Other data structures
  y = array (1,n) (zip [1..] ys) if x ! i == y ! j then table ! (i-1,j-1) else 1 + table ! (i-1,j-1)]
  4 KB (640 words) - 21:05, 6 January 2019
• Free structure
  *** <math> x * (y * z) = (x * y) * z </math> *** <math> x + y = y + x </math>
  13 KB (2,245 words) - 15:18, 6 February 2021
• 99 questions/1 to 10
  λ> myLast ['x','y','z'] 'y'
  5 KB (719 words) - 05:27, 10 June 2023
• Haskell a la carte
  average x y = (x+y)/2 average x y = (x+y)/2
  6 KB (1,024 words) - 23:56, 25 June 2021
• Recursive function theory
  ...\left(\mathbf s y\right) = h x_0 \dots x_{m-1} y \left(g x_0\dots x_{m-1} y\right)</math> ...s x_{m-1} \left(\mathbf s y\right) = \mathbf S_{m+1} h g x_0 \dots x_{m-1} y</math>
  13 KB (2,068 words) - 23:19, 3 June 2019
• IO in action
  let !y = k x u2 in y
  4 KB (674 words) - 07:12, 12 June 2023
• OpenGLTutorial2
  ...oblem, let's break apart our program a little bit, forming several more or less independent code files linked together to form a whole. vertex3f (x, y, z) = vertex $ Vertex3 x y z
  20 KB (3,092 words) - 11:52, 20 September 2013
• Monad
  thing1 >>= (\x -> func1 x >>= (\y -> thing2 >>= (\_ -> func2 y >>= (\z -> return z))))
  13 KB (1,870 words) - 11:14, 22 October 2022
• Correctness of short cut fusion
  g = \x y -> case x y of Just z -> 0 ...s" as above, that the right-hand side (<hask>g c n</hask>) can be strictly less defined than the left-hand side (<hask>foldr c n (build g)</hask>).
  15 KB (2,468 words) - 01:17, 8 April 2016
• Arrow tutorial
  -- = \op -> arr (\(x,y) -> x `op` y) |<code>second g</code> ⇔ <code>3*y + 1</code>, where <code>y</code> is the second component of the pair
  8 KB (1,315 words) - 00:43, 16 May 2024
• Yhc/RTS/Exceptions
  IO y -> y w (IO x) >> (IO y) = IO $ \ w -> x w `seq` y w
  8 KB (1,141 words) - 01:44, 14 July 2021
• 99 questions/80 to 89
  ...edge from a node x to another node y is represented as e(x,y), the term e(y,x) is not present. '''The graph-term form is our default representation.''' ...(i.e. functor '-' and arity 2). The atoms stand for isolated nodes, the X-Y terms describe edges. If an X appears as an endpoint of an edge, it is auto
  11 KB (1,679 words) - 06:20, 11 June 2023
• Cookbook/Dates And Time
  (y,m,d) = toGregorian $ utctDay c --> (2009,4,21)
  2 KB (224 words) - 21:06, 6 January 2019
• Monads as containers
  That is, a list [x,y,z] represents a value which is all of the values x, y, [10,20,30] >>= \x -> [x, x+1] >>= \y -> if y > 20 then [] else [y,y]
  18 KB (3,270 words) - 05:36, 9 March 2021
• Fold
  pairs f (x:y:t) = f x y : pairs f t ...of a left fold, the structural transformation being performed is somewhat less natural, but is still quite regular:
  12 KB (1,923 words) - 18:51, 28 March 2019
• Random shuffle
  toElems (x, y) = (elems x, y)
  5 KB (743 words) - 13:10, 9 May 2017
• Xmonad/Config archive/adamvo's xmobarrc
  , Run Date "%a %b %_d %Y %H:%M:%S" "date" 10
  2 KB (189 words) - 01:17, 9 April 2021
• The Monad.Reader/Issue3/Functional Programming vs Object Oriented Programming
  data (Exp x, Exp y) => Then x y = Then x y instance (Exp x, Exp y) => Exp (Then x y)
  10 KB (1,718 words) - 07:14, 10 August 2022
• Blow your mind
  foldr (\a ~(x,y) -> (a:y,x)) ([],[]) diff xl@(x:xs) yl@(y:ys) | x < y = x:diff xs yl
  12 KB (1,704 words) - 17:53, 22 November 2019
• Logic programming example
  mapM_ print (solve_puzzle (\x y -> x == y && x == Male)) mapM_ print (solve_puzzle (\x y -> x == y && x == Female))
  14 KB (2,307 words) - 12:23, 31 July 2014
• Xmonad/Config archive/Gwern's xmonad.hs
  ...xK_v), spawn "/home/gwern/bin/bin/logprompt.sh /home/gwern/doc/$(date +%Y)/log.txt") ...sk,xK_v), spawn "/home/gwern/bin/bin/logprompt.sh /home/gwern/doc/$(date +%Y)/log-media.txt")]
  6 KB (615 words) - 23:47, 28 November 2018
• Keywords
  f !x !y = x + y [ (x,y) | x <- [1..10], y <- ['a'..'z'] ]
  22 KB (3,350 words) - 04:31, 8 June 2023
• Euler problems/71 to 80
  Brute force but still finds the solution in less than one second. edgePair [x, y, z] = [(x, y), (y, z)]
  7 KB (972 words) - 02:57, 3 May 2015
• Diagrams/Dev/Freezing
  square x # lw y # scale s Absolute: (y * w) / (s * x)
  10 KB (1,576 words) - 22:57, 30 November 2013
• Maintaining laziness
  force y = let Just x = y
  20 KB (3,325 words) - 12:02, 19 April 2024
• Chaitin's construction
  :<math>\widehat{\left(x y\right)} \equiv 1 \widehat x \widehat y</math> ...ert\left(x\;y\right)\right\Vert = 1 + \left\Vert x\right\Vert + \left\Vert y\right\Vert</math>
  10 KB (1,527 words) - 09:31, 24 April 2024
• Contstuff
  y <- pure (x+1) <|> pure (x-1) return (x, y)
  12 KB (2,067 words) - 05:43, 9 March 2021
• State Monad
  getNext >>= \y -> y <- getNext
  7 KB (1,055 words) - 15:06, 21 December 2018
• Newtype
  ...ther <hask>x</hask> is <hask>⊥</hask> or <hask>Any y</hask> for some <hask>y</hask>.
  6 KB (1,007 words) - 15:57, 22 May 2016
• Euler problems/181 to 190
  score guess answer = foldr (\(a,b) y -> if a == b then y+1 else y) 0 where choose x [y] = intToDigit y
  15 KB (2,018 words) - 01:29, 26 April 2021
• Literate programming
  tsort (x:xs) = tsort [y | y<-xs, y>x] ++ [x] ++ tsort [y | y<-xs, y<=x]
  10 KB (1,524 words) - 22:20, 13 November 2022
• Dmenu-4.0-xft.diff
  + XftDrawStringUtf8(dc.xftdrawable, &dc.xftnorm[ColFG], dc.font.xftfont, x, y, (unsigned char*) buf, len); XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
  7 KB (986 words) - 15:19, 6 February 2021
• Prime numbers miscellaneous
  mergeP xs@(Crowd (x:xt)) ys@(VIP y yt) = case compare x y of GT -> VIP y $ mergeP xs yt
  18 KB (2,583 words) - 20:08, 19 December 2020
• Type arithmetic
  data Less class Cmp x y c | x y -> c
  8 KB (1,365 words) - 19:23, 15 August 2019
• GetOpt
  Note: You can make this a little less painful by factoring out the to be accessed, so maybe you end up writing less boilerplate overall
  10 KB (1,542 words) - 05:40, 8 June 2023
• Es/Librerias y Herramientas/Estructuras de Datos
  {{Es/Traducción en progreso|titulo=Librerias y Herramientas/Estructuras de Datos}} == Librerias y herramientas para Estructuras de datos en Haskell ==
  10 KB (1,459 words) - 19:29, 15 August 2019
• Syntactic sugar/Cons
  but "lacks" the possibility to add arguments like in <hask>x `rel c` y</hask>. like <hask>[f x, f y, g z]</hask>.
  16 KB (2,610 words) - 17:17, 4 February 2023
• Guess a random number
  -- Prompt until a valid Y / N (case-insensitive) is read, and return it. return $ again == 'Y'
  5 KB (787 words) - 15:17, 6 February 2021
• Shootout/Fannkuch
  case readIntOffAddr# a j s of { (# s, y #) -> case writeIntOffAddr# a i y s of { s ->
  22 KB (3,539 words) - 00:49, 14 December 2016
• Ru/GHC/Class Instance Extensions
  (x:xs) === (y:ys) = True
  3 KB (170 words) - 23:05, 29 June 2021
• Foldr Foldl Foldl'
  ...then return ''y''. The idea is that ''y'' references ''x'' so that when ''y'' is reduced ''x'' will not be a big unreduced chain anymore. > x ? y = x*y
  16 KB (2,235 words) - 10:26, 29 March 2019
• Euler problems/41 to 50
  y <- filter (sequ s . take 3) $ filter (notElem (head s)) ys return (head s:y))
  12 KB (1,626 words) - 05:45, 9 March 2021
• 99 questions/Solutions/70
  stringToTree (x:xs@(y:ys)) | y == '^' = Node x []
  7 KB (1,025 words) - 02:14, 23 July 2021
• Foldable Traversable In Prelude
  - mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) - mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
  14 KB (2,640 words) - 11:47, 26 November 2023
• MapReduce as a monad
  g' x y = run (g x) y
  6 KB (1,053 words) - 03:27, 9 April 2021
• OpenGLTutorial1
  mapM_ (\(x, y, z) -> vertex $ Vertex3 x y z) myPoints vertex3f x y z = vertex $ Vertex3 x y (z :: GLfloat)
  10 KB (1,585 words) - 09:22, 20 September 2013
• Modular Monadic Compilers for Programming Languages
  mainD3 = compile (readv 'y') mainW2 = compile (sequ (attr 'x' (constant 45)) (attr 'y' (constant 50)) )
  20 KB (2,558 words) - 22:39, 29 June 2021
• GHC/Using rules
  ...of output so you'll want to direct the output to a file or pipe it to <tt>less</tt>. Looking at the output of this can help you figure out why rules are n {-# RULES "fusable/aux" forall x y.
  19 KB (3,096 words) - 17:21, 4 February 2023
• Regex Posix
  Regex pattern: "X(.?){0,}Y" Regex pattern: "X(.?){1,}Y"
  26 KB (3,619 words) - 03:30, 10 March 2017
• Nitpicks
  where bind3 f x y z = join (liftA3 f x y z)
  7 KB (1,033 words) - 01:16, 27 September 2021
• Monomorphism restriction
  ...ypes using "type defaulting" rules. The resulting type signature is always less polymorphic than you'd expect, so often this results in the compiler throwi ...it's considered clear that sharing f1 will not share any computation, and less clear that sharing f2 will have the same effect. If this seems arbitrary, t
  16 KB (2,628 words) - 21:19, 16 December 2022
• Arrow
  ...a) \left(i:x\right) y \Leftrightarrow i\begin{cases}0:&x\rho y\\1:&x\sigma y\end{cases}</math>
  11 KB (1,636 words) - 20:01, 13 May 2020
• ListT done right
  y <- squares lift $ print (x,y)
  13 KB (2,036 words) - 13:54, 4 July 2023
• GHC/Data Parallel Haskell
  ...denotes a three element parallel array with elements <hask>x</hask>, <hask>y</hask>, and <hask>z</hask>; and <hask>[:x + 1 | x <- xs:]</hask> represents dotp xs ys = sumP [:x * y | x <- xs | y <- ys:]
  21 KB (3,158 words) - 08:39, 10 August 2022
• Tying the Knot
  cyclic = let x = 0 : y y = 1 : x
  24 KB (3,850 words) - 17:16, 28 June 2021
• Yi/FAQ
  | Ctrl-y |C-y
  9 KB (1,413 words) - 00:17, 24 November 2014
• 10分で学ぶHaskell
  :Prelude> :t <hask>[('x', True), ('y', False)]</hask> :<hask>[('x', True), ('y', False)] :: [(Char, Bool)]</hask>
  17 KB (1,020 words) - 07:22, 9 June 2023
• Cabal/Developer-FAQ
  > packages i = foldl1 (\x y -> x ++ " " ++ y) (map showPackage (packageDeps i))
  7 KB (998 words) - 12:32, 2 October 2020
• Humor
  *[[Humor/Y-agra|Need help performing?]]
  5 KB (667 words) - 22:52, 1 May 2024
• IO Semantics
  !y = k x u2 in in y
  11 KB (1,628 words) - 10:36, 5 April 2024
• A brief introduction to Haskell
  Prelude> let y = x + 3 Prelude> :t y
  41 KB (6,592 words) - 22:27, 3 May 2024
• New monads/MonadAdvSTM
  yv <- readTVar y yv <- readTVar y;
  24 KB (3,463 words) - 05:20, 12 July 2021
• Debugging
  g x = let Just y = f x in h y, Irrefutable pattern failed for pattern Data.Maybe.Just y
  9 KB (1,453 words) - 19:18, 3 February 2021
• Regular expressions for XML Schema
  delta (Sym y) x | x == y = Unit
  22 KB (3,425 words) - 22:34, 29 June 2021
• Thompson-Wheeler logo
  \begin{tikzpicture}[x=1ex,y=1ex]<br/>
  3 KB (488 words) - 16:11, 3 August 2013
• Non-strict semantics
  ifThenElse False _ y = y
  9 KB (1,503 words) - 13:55, 15 December 2019
• WxHaskell/Quick start
  -- constants: radius of the ball, and the maximal x and y coordinates -- the max. height is at most max. y minus the radius of a ball.
  14 KB (2,248 words) - 15:18, 6 February 2021
• HUnit 1.0 User's Guide
  test2 = TestCase (do (x,y) <- partA 3 b <- partB y
  23 KB (3,542 words) - 03:11, 15 May 2020
• Xmonad/Config archive/TeXitoi's xmonad.hs
  clock = textClockNew Nothing "%Y-%m-%d %H:%M" 1
  4 KB (452 words) - 14:23, 2 May 2018
• Haskell programming tips
  raise x (y:ys) = x+y : raise x ys y:ys <- tails xs
  29 KB (4,702 words) - 12:36, 4 May 2021
• Haskell programming tips/Discussion
  ...ve someone is seriously advocating to replace <hask>(&$ x)</hask> with the less readable <hask>flip (&$) x</hask> just because that's the way one specific ...cally render combinator libraries unusable, which would make Haskell a lot less attractive. -- RemiTurk
  24 KB (4,110 words) - 01:13, 7 November 2020
• Foldable and Traversable
  where map_one (x:xs) y = (xs, g y x)
  11 KB (1,895 words) - 19:00, 18 May 2020
• OOP vs type classes
  coord (FloatPoint x y) = (x,y) coord (IntPoint x y) = (realToFrac x, realToFrac y)
  30 KB (4,685 words) - 01:34, 14 July 2021
• Diagrams/Dev/Transformations
  ...inear map that scales all <math>x</math>-coordinates by 2 but leaves <math>y</math>-coordinates unchanged. But what if we want to obtain another vector corresponds to the function <math>\lambda (x,y) \to (x + 2y, 3x + 4y)</math>.
  14 KB (2,245 words) - 03:01, 11 April 2015
• Fully-functional heterogeneous lists
  substitute x y = Wrp (unsafeCoerce x::t2) substitute x y = Wrp (unsafeCoerce x::t2)
  28 KB (3,716 words) - 13:01, 20 October 2017
• X window programming in Haskell
  the window to be created, the ''x'' position, the ''y'' position, the width, The ''x'' and ''y'' positions are relative to the upper left corner of the
  61 KB (8,858 words) - 11:47, 5 November 2020
• Plainly partible
  ...arts (u, v, w, x, y) = zip5 (parts u) (parts v) (parts w) (parts x) (parts y)
  11 KB (1,656 words) - 22:33, 4 July 2022
• Performance/GHC
  * <tt>-optc-ffast-math</tt>: A C-compiler option which allows it to be less strict with respect to the standard when compiling IEEE 754 floating point In general, splitting code across modules should not make programs less efficient. GHC does quite aggressive cross-module inlining: when you impor
  25 KB (3,873 words) - 11:08, 6 March 2023
• Humor/Erlkönig
  > My intention is to generate 50 random coordinates like (x,y).
  5 KB (787 words) - 11:02, 26 December 2017
• Parallel/Glossary
  ...arks are introduced with the par combinator; the expression (<code>x `par` y</code>) "sparks off" <code>x</code>, telling the runtime that it may evalua
  4 KB (637 words) - 02:02, 6 May 2024
• Blog articles/Mathematics
  * [http://www.onebadseed.com/blog/?p=51 Don't need the Y combinator]
  9 KB (903 words) - 07:20, 16 April 2020
• Numeric Haskell: A Repa Tutorial
  ghci> let y = Repa.map (^2) x ghci> y Repa.! (Z :. 0 :. 2)
  37 KB (5,672 words) - 07:28, 10 August 2022
• HacBerlin2014/Topics
  ...tate Y. Do some arbitrarily chosen part-testcases begining with that state Y.""
  8 KB (1,326 words) - 20:19, 28 September 2014
• OpenWRT
  #define mouse_trafo(y,x,to_screen) wmouse_trafo(stdscr,y,x,to_screen)
  13 KB (1,967 words) - 16:07, 9 August 2016
• FFI cook book
  GHC allows this constructor-less version (with EmptyDataDecls): > y <- c_Foo(x)
  16 KB (2,449 words) - 17:06, 17 April 2017
• Introduction to Haskell IO
  #### liftM2 is just short for do { x <- act1; y <- act2; return (x `op` y) }
  10 KB (1,520 words) - 07:20, 10 November 2020
• HXT/Conversion of Haskell data from/to XML
  , Assign y (IntConst 7) , Assign p ( BinExpr Add (Var p) (Var y) )
  28 KB (3,540 words) - 18:19, 5 January 2015
• CPlusPlus from Haskell
  class HBool b => TypeEq x y b | x y -> b
  15 KB (2,199 words) - 00:32, 23 May 2017
• Diagrams/Dev/Constraints
  ...ything besides some accessors (untrie f XB and untrie f YB for accessing x/y components resp. of V2). We already have Coordinates and HasBasis though, s * linear? - supported in Z3, I implemented a few (alignAxis, spacingX/Y)
  10 KB (1,671 words) - 03:59, 16 August 2014
• Continuation tutorials timeline
  ...inuation <tt>k</tt> contains the code that will be executed after <tt>(+ x y)</tt> is calculated."
  6 KB (866 words) - 02:16, 2 May 2024
• Manatee
  sudo aptitude install binutils-gold -y ...gtkimageview-dev libpoppler-glib-dev poppler-data libtagc0-dev libvte-dev -y
  12 KB (1,458 words) - 02:36, 26 April 2021
• The Monad.Reader/Issue2/FunWithLinearImplicitParameters
  Again, in this term, <hask>k'</hask> is bound to <hask>\y -> reset [x + y]</hask>, so <hask>k</hask> is the function ...answer to the question which one GHC chooses when no signature is given is less satisfactory: It depends on the status of the flag <hask>-f(no)monomorphism
  35 KB (5,673 words) - 20:05, 7 July 2015
• Template Haskell
  lamE [foldr (\x y -> conP '(:) [varP x,y]) wildP ns] (tupE $ map varE ns) getopt (THNoArg pat) = lamE [varP "y"] (caseE (varE "y") [cons0, cons1])
  30 KB (4,551 words) - 00:29, 15 June 2023
• FAQ
  ...ience may actually have an easier time learning Haskell, because they have less to un-learn. f x y = do ...
  36 KB (5,814 words) - 22:06, 10 May 2024
• Haskell IO for Imperative Programmers
  mischief x = let y = 141421 * x y
  20 KB (3,555 words) - 06:05, 24 April 2024
• Sudoku
  let printLine a y = mapM (\x -> readBoard a (x,y)) [1..9] >>= mapM_ (putStr . show) in do
  67 KB (9,593 words) - 05:40, 9 March 2021
• Nonogram
  unify x y | x == y = x
  17 KB (2,482 words) - 20:34, 8 June 2017
• XHB
  ...ests, it needs to handle each event in a rather short period of time (e.g. less that 200 milliseconds, as a rule of thumb)
  5 KB (883 words) - 14:29, 3 April 2014
• Tutorials/Programming Haskell/Argument handling
  render Squeeze = map head. groupBy (\x y -> all (all isSpace) [x,y]) render Squeeze = map head. groupBy (\x y -> all (all isSpace) [x,y])
  25 KB (3,657 words) - 18:20, 12 September 2015
• 99 questions/95 to 99
  ,'O'),((3,3),'P'),((4,3),'P'),((5,3),'Y'),((3,5),'A'),((4,5),'R'),((5,5),'E'),((
  8 KB (894 words) - 02:36, 25 November 2022
• Yhc/Javascript/Programmers guide/Up from the ground
  "(function(x,y){return (x - (x % y))/y;})(exprEval(a),exprEval(b));"
  21 KB (3,466 words) - 15:19, 6 February 2021
• Learn Haskell in 10 minutes
  .... If you indent more, it's part of the previous statement. If you indent less, it ends the <hask>do</hask> block. This is called "layout", and Haskell u Prelude> :t [('x', True), ('y', False)]
  13 KB (1,986 words) - 17:59, 9 August 2019
• Prime numbers
  ...orresponding to <i>n (log n)² log log n</i> complexity, more or less, in ''n'' primes produced): minus (x:xs) (y:ys) = case (compare x y) of
  58 KB (8,594 words) - 20:34, 6 May 2023
• Fully-functional heterogeneous lists (ru)
  substitute x y = Wrp (unsafeCoerce x::t2) substitute x y = Wrp (unsafeCoerce x::t2)
  34 KB (2,180 words) - 13:00, 20 October 2017
• Intrebarile incepatorului
  * [[Ce tip are combinatorul Y ?]] 1.5 * [[Ce tip are Y - combinatorul paradoxal ?]]
  14 KB (1,971 words) - 23:12, 9 April 2021
• Ru/IO
  math x y = do xy = x*y
  25 KB (918 words) - 06:01, 1 June 2022
• SceneGraph
  ...'scale' function. This takes a vector indicating by how much to scale in X,Y and Z directions:
  6 KB (988 words) - 04:52, 26 April 2021
• Evaluation order and state tokens
  add !x y = x + y ...y be printed multiple times, and &quot;finished thunk&quot; may be printed less times than &quot;starting thunk&quot;. This can't even be worked around by
  21 KB (3,408 words) - 09:26, 9 September 2014
• Ministg
  plusInt = FUN(x y -> I i -> case y of {
  15 KB (2,396 words) - 07:19, 10 August 2022
• Glome tutorial
  ...s specified by a vector, which can be constructed by calling "vec" with x, y, and z arguments. ...this point, we need to decide which direction is up. I usually pick the "Y" axis as pointing up, So, to set up a camera at position <20,3,0> looking a
  40 KB (6,787 words) - 01:19, 8 April 2014
• Links
  *<b>Y:</b>
  11 KB (1,759 words) - 09:41, 10 August 2022
• GHC/FAQ
  let { x = case e of ...; y = case e of ... } in ... let { v = e; x = case v of ...; y = case v of ... } in ...
  36 KB (5,898 words) - 06:04, 10 August 2022
• GHC/Using the FFI
  y <- twice squareW x -- use the foreign function with our callback z <- twice squareW y
  29 KB (4,766 words) - 05:52, 1 June 2022
• Introduction to QuickCheck1
  Ah! QuickCheck caught us out. If the input string contains less than 5 filterable characters, the resulting string will be less than 5
  8 KB (1,186 words) - 20:49, 28 May 2021
• Programming guidelines
  x <- return y let x = y
  17 KB (2,651 words) - 09:36, 10 August 2022
• Xmonad/Screenshots
  ...xmonad-docs/xmonad-contrib/XMonad-Layout-Reflect.html Reflect] across X or Y axis
  13 KB (1,464 words) - 02:28, 20 October 2014
• Humor/Wanda
  Windows found - Remove? (Y)es (S)ure (F)ine (O)K (M)ake it so
  8 KB (1,343 words) - 09:02, 13 March 2016
• Xmonad/Config archive/Nnoell's xmonad.hs
  , "-y", "0" (dzenBoxStyleL whiteBoxPP $ date $ "%Y^fg(" ++ colorGray ++ ").^fg()%m^fg(" ++ colorGray ++ ").^fg()^fg(" ++ color
  45 KB (4,625 words) - 00:21, 27 October 2013
• Foreign Function Interface
  add = x+y my_primop (I64# x) (I64# y) = IO $ \s ->
  33 KB (5,008 words) - 16:46, 20 December 2023
• IO inside
  ...important in these days of multi-core CPUs. Finally, pure computations are less error-prone and easier to verify, which adds to Haskell's robustness and to c | c == 'y' -> "Now"
  82 KB (13,140 words) - 09:07, 3 May 2024
• Simonpj/Talk:OutsideIn
  ...e the notation t1 <= t2 for "t1 is more general than t2"; we are using a "less than" symbol for a concept involving the word "more"... Also, it took me a * p.55, Fig. 21: Suppose we had an equality F x y z ~ G a b c, how would it be flattened? It seems we need to flatten away t
  9 KB (1,527 words) - 09:11, 10 August 2022
• Top level mutable state
  ...nk that availability of an ugly solution (e.g. unsafePerformIO, or maybe a less unsafe construct) is required, but that it is not really required to be ele if <hask>do { x <- u; y <- v; w } === do { y <- v; x <- u; w } </hask> for all actions <hask>v</hask> and <hask>w</hask>
  29 KB (4,624 words) - 05:37, 1 January 2022
• Typeclassopedia
  * Interchange:<br /><haskell>u <*> pure y = pure (\f -> f y) <*> u</haskell>Intuitively, this says that when evaluating the application ...lar we consider <code>(x,()) ≅ x ≅ ((),x)</code> and <code>((x,y),z) ≅ (x,(y,z))</code>.}}
  179 KB (29,519 words) - 16:10, 30 December 2022
• A practical Template Haskell Tutorial
  map3 f (x:xs) (y:ys) (z:zs) = f x y z : map3 f xs ys zs ...ion <hask>apply</hask> used to generate <hask>map3</hask>'s body <hask>f x y z : map3 f xs ys zs</hask> shows the use of quotation brackets; it also hig
  45 KB (6,927 words) - 18:50, 16 November 2020
• Xmonad/Guided tour of the xmonad source/StackSet.hs
  ...>,remember?) to <hask>RationalRect</hask>s, which simply store x position, y position, width, and height. Note that floating windows are still stored i
  16 KB (2,690 words) - 16:02, 26 December 2022
• Applications and libraries/Games
  :[https://www.youtube.com/watch?v=v_GSbObYRkY Y-Wing flight] is a video of a demonstration of the possibilities of HGamer3D
  15 KB (2,258 words) - 16:22, 1 July 2023
• Haskellへのヒッチハイカーガイド
  "darcs add cd-fit.hs" and "darcs record", answer "y" to all questions ...ne" is just another syntax sugar. Note that when function is supplied with less arguments that it actually needs, we get not a value, but a new function, w
  73 KB (10,050 words) - 00:05, 19 April 2021
• Monad tutorials timeline
  ...What we need is some way to capture the pattern 'do X and then do Y, where Y may be affected by X'. Monads are the way we do this." ... "In a sense, eac *: Wikibook rewrite of the original monads tutorial. Less fluff, more pedagogy. [In progress at the time of this writing].
  35 KB (4,953 words) - 00:05, 9 May 2024
• Research papers/Functional pearls
  ...ce/papers/rsr.ps Recursive subtyping revealed] - Vladimir Gapeyev, Michael Y. Levin and Benjamin C. Pierce.
  20 KB (2,961 words) - 16:50, 6 February 2024
• Haskell in practice
  ...vy. <p> The results indicate that the Haskell prototype took significantly less time to develop and was considerably more concise and easier to understand ...H. Flood, W. Grieskamp, J. H. G. van Groningen, K. Hammond, B. Hausman, M. Y. Ivory, R. E. Jones, J. Kamperman, P. Lee, X. Leroy, R. D. Lins, S. Loosemo
  14 KB (2,263 words) - 06:31, 10 August 2022
• HXT
  = foldl1 (\ x y -> x >>> getChildren >>> y) -- (1)
  48 KB (6,937 words) - 00:20, 27 April 2016
• Haskell logos/New logo ideas
  - It also looks like a Y tilting to the right, which is a reference to the Y combinator. .... [[Media:Haskell-tao.svg|SVG]] available. Font is Lucida Calligraphic, a less ubiquitous calligraphic font might be better.
  34 KB (5,126 words) - 19:19, 15 August 2019
• Xmonad/Config archive
  :Ratpoison-y keybindings; example usage of XSelection with searches. zipWithM_ (\x y -> writeFile x =<< y) (map ((++ ".hs") . show) [(1::Int)..]) hs
  29 KB (4,125 words) - 12:46, 15 January 2021
• Hitchhikers guide to Haskell
  ...ne" is just another syntax sugar. Note that when function is supplied with less arguments that it actually needs, we get not a value, but a new function, w * "liftM2" is defined as "liftM2 f a1 a2 = do x<-a1; y<-a2; return (f x y)"
  69 KB (11,026 words) - 12:26, 9 January 2023
• All About Monads
  ...blocks of code that can be used to construct many different computations. Less obviously, monads also promote modularity by allowing you to vary the monad ...orts the most common monad functions, and the Monad module, which contains less-commonly used monad functions. The individual monad types are each in their
  169 KB (26,630 words) - 00:15, 19 September 2021
• GHC/GHCi
  ...</span><span style="color:#b860ff; font-weight:1000">'''λ'''</span> :pl \x y -> x + 1 -- converts code to point-free (aka pointless)
  21 KB (3,021 words) - 12:03, 15 May 2020
• FFI imports packaging utility
  ...for the '''C''' preprocessor and compiler, use for example: <code> -c "-DX=Y"</code>
  19 KB (2,929 words) - 23:51, 13 September 2013
• Ru/IO Inside
  ...function that has the type 'x -> y -> ... -> IO a' and provide all the x, y, etc. parameters. But you're not limited to this standard scenario - let moveF (addX,addY) = do (x,y) <- readIORef centerVar
  64 KB (6,046 words) - 11:23, 22 October 2022
• Hackage wiki page per project discussion
  ...terested to have any legal precedent with the Haskell community. Because, `Y'know` how that would be perceived by the developer's community. If Microsof
  18 KB (3,049 words) - 10:29, 7 February 2021
• Research papers/Compilation
  :Y. Onoue, Z. Hu, H. Iwasaki, M. Takeichi, IFIP TC 2 Working Conference on Alg
  19 KB (2,599 words) - 00:14, 15 June 2023
• Applications and libraries/Mathematics
  ...both at the value and type levels, with () taking the place of nil. So x:.y:.z:.() is a 3d vector. The library provides a set of common list-like funct
  21 KB (2,880 words) - 09:43, 4 May 2024
• Library/CC-delcont
  p5 <- provideString "y dog" p4 >>= finish
  25 KB (4,039 words) - 16:39, 12 March 2024
• Xmonad/Frequently asked questions
  where fraction x y = floor (x * fromIntegral y)</haskell> Then set the logHook in your config to &ldquo;pointerFollowsFocus <i>x</i> <i>y</i>&rdquo;. If you already have a logHook, append &ldquo;
  71 KB (10,765 words) - 16:38, 22 August 2021
• Haskell Tutorial for C Programmers
  float x = 2.5, y = 7.0; cout << a + y; //11
  111 KB (19,450 words) - 17:55, 23 October 2019
• HIDE
  ...or example when using a module that needs pre-processing, eg a .hsc .chs. .y or .x file, then the modules view would show only that file and not the gen
  24 KB (4,039 words) - 04:38, 24 April 2021
• Books
  ...|frameless|right|Cover]] Blas C. Ruiz, Francisco Gutiérrez, Pablo Guerrero y José E. Gallardo. [http://www.lcc.uma.es/~pepeg/pfHaskell/index.html <em>R Computación, y otras ciencias en general ( Matemáticas, Física, etc.).
  53 KB (7,703 words) - 13:28, 28 March 2024
• Xmonad/General xmonad.hs config tips
  echo '^scrollhome()' ) | dzen2 -fg $fgCol -bg $bgCol -x 700 -y 36 -l 22 -ta l -w 900 -p -- | hidden, non-empty workspaces less scratchpad
  37 KB (5,217 words) - 02:13, 12 April 2019
• Stiri Ro/Haskell-2011
  ...nia, de catre prof Manuel Cárdenas (Universidad de Sevilla Dept. Geometría y Topologíala) probabil ca parte a documentarii despre noile aparitii de mat
  27 KB (4,177 words) - 15:10, 18 February 2015
• QuotesPage
  the world is complex and the more you understand the less certain things become. <blackdog> this y combinator, which was given to you for the recursion of sins
  55 KB (8,884 words) - 01:18, 10 November 2022