Search results
Jump to navigation
Jump to search
Page title matches
- {{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
- A simple utility to repeatedly print <code>"y"</code> to standard output. main = let y = putStrLn "y" >> y in y472 bytes (67 words) - 03:24, 26 April 2021
- and here is the proof that <hask>((.) <$> (:) <*> (:)) = (\y z -> y:y:z)</hask>: \y -> (\x -> (.) (x:)) y (y:) = -- definition of (<*>) for functions2 KB (220 words) - 20:45, 28 December 2014
- gcd' 0 y = y gcd' x y = gcd' (y `mod` x) x777 bytes (117 words) - 19:42, 18 January 2014
- where fCycle (x:xs) (_:y:ys) | x == y = fStart xxs xs950 bytes (133 words) - 00:39, 5 February 2019
- variables (Add x y) = variables x ++ variables y variables (Sub x y) = variables x ++ variables y2 KB (315 words) - 08:34, 12 May 2016
- uncommon x y=common (finalsort (x++y)) common (x:y:zs)857 bytes (148 words) - 04:14, 18 June 2021
- { fie y 2; fie x x-(fie y 1);3 KB (276 words) - 15:17, 6 February 2021
- getReps (y:ys) | y == x = let (f,r) = getReps ys in (y:f, r)2 KB (347 words) - 21:03, 20 December 2018
- data Infix f y = f :- y x -:f:- y = x `f` y2 KB (240 words) - 23:49, 18 April 2021
- Prelude.False ? (_ : y) = y False ? (_ :? y) = y847 bytes (121 words) - 23:08, 24 July 2021
- f <$> x <*> y Since f is not a pure function, it's f :: x -> y -> m c. The correct form would be2 KB (365 words) - 18:50, 19 September 2017
- 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
- g y = bind x y g y = bind x y772 bytes (147 words) - 15:19, 6 February 2021
- add x t@(Branch y l r) = case compare x y of LT -> Branch y (add x l) r741 bytes (117 words) - 22:03, 23 April 2021
- layoutAux x y sep Empty = Empty layoutAux x y sep (Branch a l r) =2 KB (299 words) - 03:42, 10 January 2017
- 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
- * 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
- 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
- helper x (y@(a,b):ys) | otherwise = (1,x):y:ys3 KB (381 words) - 02:13, 5 March 2019
- .../code>がIOアクションなら、<code>(x >> y)</code>は<code>x</code>を実行し、結果を破棄し、そのあと<code>y</code>を実行してその結果を返します。 x >> y = x >>= const y7 KB (299 words) - 11:39, 22 October 2022
- 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
- (\x -> 2*x*x + y) (\x -> 2*x*x + y)(7)878 bytes (133 words) - 16:57, 6 February 2016
- 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
- generate (x :+ y) = binaryOp x y add generate (x :- y) = binaryOp x y sub3 KB (386 words) - 21:41, 23 April 2021
- Partial application in Haskell involves passing less than the full number of arguments to a function that takes multiple argumen add x y = x + y1 KB (248 words) - 20:05, 13 May 2020
- $ ./a.out "%a %b %e %H:%M:%S %Z %Y" $ ./a.out "%y-%m-%d"543 bytes (78 words) - 15:19, 6 February 2021
- range x y = [x..y] range x y = take (y-x+1) $ iterate (+1) x1 KB (214 words) - 02:08, 5 April 2014
- adjacent = [x | (x,y)<-e,y==top] ++ [x | (y,x)<-e,y==top]714 bytes (91 words) - 03:50, 10 January 2017
- f x = (\y -> x + y)566 bytes (92 words) - 13:53, 1 January 2017
- adjacent = [x | (x,y)<-e,y==top] ++ [x | (y,x)<-e,y==top]1 KB (123 words) - 03:51, 10 January 2017
- ...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
- ...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
- y:ys -> h y ys y:ys -> uncurry h $ viewRTotal y ys3 KB (506 words) - 04:03, 4 September 2017
- tfs (x:y:xs) | y == ',' || y == ')' = return (y:xs, Branch x Empty Empty)2 KB (372 words) - 03:43, 10 January 2017
- (Key _ x) `mappend` (Key k y) = Key k (x `mappend` y) measure (Elem x y) = Key x y2 KB (315 words) - 15:19, 6 February 2021
- 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
- \x y -> ... fun x y -> ...2 KB (293 words) - 16:34, 15 May 2023
- polar (x, y) = atan2 (y - y0) (x - x0) grahamScan' xs [y] = y : xs2 KB (298 words) - 03:42, 14 August 2021
- > 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
- !y -> h y u2 !y -> h y u213 KB (2,108 words) - 12:52, 1 January 2024
- 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
- where swap (x,y) = (y,x)722 bytes (109 words) - 19:45, 18 January 2014
- safeDiv x y = Right (x `div` y)877 bytes (61 words) - 02:13, 14 November 2023
- y <- x case y of4 KB (707 words) - 09:43, 9 December 2014
- f x = y where y = ... x ...4 KB (716 words) - 07:41, 26 January 2019
- ...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
- 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
- ...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
- gray' n = (gl . gr) [] where gl y = foldr (\s acc -> ('0':s):acc) y gp gr y = foldl (\acc s -> ('1':s):acc) y gp2 KB (298 words) - 03:02, 7 June 2021
- let y = sum [0..47] in x `seq` 3 + y + y^24 KB (716 words) - 14:44, 8 January 2024
- let !y = k x u2 in y4 KB (691 words) - 08:14, 12 June 2023
- ...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
- ...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
- :<code>(\ x -> x x) (\ y -> y)</code> :<code>(\y -> y) (\y -> y)</code>4 KB (617 words) - 03:01, 9 April 2021
- mirror (Branch _ a b) (Branch _ x y) = mirror a y && mirror b x1 KB (179 words) - 13:36, 25 December 2016
- lift f x (y,chain) = (x, (f,y):chain) lift f (Just x) y | f x y = Just y3 KB (543 words) - 23:08, 26 January 2016
- rotate x y | y > 0 = rotate (tail x ++ [head x]) (y-1)3 KB (474 words) - 20:35, 23 May 2021
- = Vector { x :: Float; y :: Float; } out vec.y -- prints '4.0'3 KB (430 words) - 11:59, 19 April 2021
- ...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
- maySwitch = if steep then (\(x,y) -> (y,x)) else id1 KB (168 words) - 23:01, 11 July 2021
- goldbachList' n m i = filter (\(x,y) -> x > i && y > i) $ goldbachList n m992 bytes (161 words) - 19:48, 18 January 2014
- compress (RPair s t) (x,y) = compress s x ++ compress t y y <- bar t8 KB (1,072 words) - 18:32, 16 January 2017
- pattern Snd y <- (x, y)2 KB (138 words) - 12:11, 22 November 2023
- |<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
- loop (y:ys) | y == '-' = (not . null) ys && isAlphaNum (head ys) && loop (tail ys) | isAlphaNum y = loop ys2 KB (346 words) - 03:47, 10 January 2017
- 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
- apply Plus x y = Just (x + y) apply Minus x y = Just (x - y)5 KB (621 words) - 15:30, 8 June 2017
- | 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
- parsePrices [x,y] = zip (words x) (map read. words $ y)1 KB (177 words) - 22:56, 5 April 2021
- 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
- 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
- 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
- ...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
- Prelude> let concatPrint x y = putStrLn $ (++) x y1 KB (159 words) - 23:45, 25 June 2021
- add (Cons x) (Cons y) = Cons (x+y) -- requires Num constraint on type a2 KB (312 words) - 23:26, 19 September 2016
- ...connected (Graph (x':xs') ys') = not $ any (null) [paths' x' y' ys' | y' <- xs']2 KB (281 words) - 03:49, 10 January 2017
- (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
- The current ''Num'' class in the Prelude is (more or less) this Z + y = y9 KB (1,395 words) - 23:16, 24 July 2021
- y <- newSTRef 1 fibST' n x y5 KB (802 words) - 05:38, 4 August 2021
- encode' n x (y:ys) | x == y = encode' (n + 1) x ys3 KB (470 words) - 03:45, 19 May 2021
- > data App x y > class Eval1 x y d | x -> y d10 KB (1,653 words) - 00:25, 12 July 2021
- [[[ poly x y | i <- [0..], let x = m + 60*i, test x y ]5 KB (679 words) - 17:14, 4 February 2023
- fmap f (Pair x y) = Pair (f x) (f y) liftL2 f x y = fmap (uncurry f) $ zipL x y7 KB (1,165 words) - 20:40, 31 October 2019
- ...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
- getRandomR (x,y) = RandT $ liftState $ randomR (x,y) getRandomRs (x,y) = RandT $ liftState $6 KB (894 words) - 13:41, 2 April 2019
- y = div n m x = xs!!y8 KB (1,054 words) - 15:53, 11 October 2015
- 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 -> y8 KB (1,326 words) - 08:20, 31 March 2022
- 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
- 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
- ...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
- y <- Just (5*7) return (x-y)10 KB (1,589 words) - 01:08, 27 September 2021
- divides x y = y `mod` x == 04 KB (546 words) - 19:18, 31 August 2016
- 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
- class Pair p x y | p -> x, p -> y where toPair :: p -> (x, y)4 KB (684 words) - 02:22, 18 May 2020
- f x y | fst z <= n2 = z | otherwise = y6 KB (881 words) - 02:31, 8 May 2016
- <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
- x <= y = compare x y /= GT x < y = compare x y == LT4 KB (572 words) - 10:25, 9 October 2019
- decodeModified = foldl (\x y -> x ++ decodeHelper y) []2 KB (362 words) - 17:33, 13 June 2020
- if' False _ y = y flipCond cond (x,y) | cond = (x,y)6 KB (937 words) - 05:34, 10 December 2020
- f x n y | n == 1 = x `mul` y4 KB (605 words) - 17:09, 18 July 2022
- 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
- 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
- ...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
- | x,y,z | x,y,z2 KB (285 words) - 01:34, 14 July 2021
- combinations n xs = [ y:ys | y:xs' <- tails xs combinations n xs = do y:xs' <- tails xs5 KB (659 words) - 19:40, 18 January 2014
- compress (x:ys@(y:_)) | x == y = compress ys3 KB (454 words) - 15:07, 2 October 2020
- ...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
- insertAt x (y:ys) n = y:insertAt x ys (n-1)2 KB (354 words) - 14:31, 5 January 2024
- Node y _ <- readIORef q print y10 KB (1,757 words) - 23:34, 24 July 2021
- ...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
- let !y = k x u2 in y8 KB (1,236 words) - 12:36, 1 January 2024
- [ (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
- 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
- second (_, y, _) = y3 KB (452 words) - 21:07, 10 March 2019
- 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
- let dists = sort $ map (\(x,y) -> abs (nodeArray ! x - nodeArray ! y)) edges3 KB (420 words) - 22:52, 7 June 2017
- g x y = if snd x < snd y then y else x if y <= n then 1 + a ! y else 1 + syr y8 KB (1,028 words) - 15:16, 16 September 2015
- y = b in f x y6 KB (1,032 words) - 16:45, 2 December 2020
- 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 its5 KB (958 words) - 15:20, 3 August 2022
- move y,d1 let s = z-(x+y)2 KB (378 words) - 23:58, 5 April 2021
- if' False _ y = y3 KB (411 words) - 11:36, 11 June 2020
- , Run Date "%a %b %_d %Y %H:%M:%S" "date" 101,023 bytes (104 words) - 15:18, 6 February 2021
- S = \x y z -> ((x z) (y z)) K = \x y -> x5 KB (664 words) - 05:48, 12 July 2021
- 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
- f (x,y) = ... f z = case z of (x,y) -> f' x y5 KB (782 words) - 16:41, 4 February 2023
- wxhaskell-x-y-z-w1 KB (187 words) - 13:26, 30 December 2015
- 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
- where toL (x:y) = (toLower x):y unCapalize (x:y) = (toLower x):y6 KB (836 words) - 19:46, 28 December 2013
- ==Y==8 KB (1,251 words) - 05:43, 1 September 2022
- ...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
- ...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 prob6 KB (802 words) - 06:27, 11 June 2023
- 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
- combs n xs = [(y:ys,rest) | y <- xs, (ys,rest) <- combs (n-1) (delete y xs)] (10x + y)/(10y+z) = x/z11 KB (1,557 words) - 09:03, 19 September 2014
- * 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 tree12 KB (1,696 words) - 05:35, 11 June 2023
- * 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
- 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 compila14 KB (2,164 words) - 16:35, 9 October 2016
- y <- readLn ; z <- return (x+y) ;3 KB (436 words) - 10:21, 29 November 2019
- (GL.Position x y) <- GL.get GLFW.mousePos modifyIORef lines (((x,y):) . ((x,y):))10 KB (1,537 words) - 21:44, 2 October 2014
- 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
- ...sk> is the "is-capital-vowel-in-English" function (ignoring the "sometimes Y").2 KB (233 words) - 17:58, 31 March 2017
- foo x y = show x == show y</pre> <pre class="haskell">foo = \ @a $dShow x y ->13 KB (2,038 words) - 10:49, 22 March 2017
- ...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 is8 KB (1,303 words) - 15:42, 18 November 2019
- 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
- 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
- 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 withou11 KB (1,668 words) - 15:16, 4 August 2019
- 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
- *** <math> x * (y * z) = (x * y) * z </math> *** <math> x + y = y + x </math>13 KB (2,245 words) - 15:18, 6 February 2021
- λ> myLast ['x','y','z'] 'y'5 KB (719 words) - 05:27, 10 June 2023
- average x y = (x+y)/2 average x y = (x+y)/26 KB (1,024 words) - 23:56, 25 June 2021
- ...\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
- let !y = k x u2 in y4 KB (674 words) - 07:12, 12 June 2023
- ...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 z20 KB (3,092 words) - 11:52, 20 September 2013
- thing1 >>= (\x -> func1 x >>= (\y -> thing2 >>= (\_ -> func2 y >>= (\z -> return z))))13 KB (1,870 words) - 11:14, 22 October 2022
- 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
- -- = \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 pair8 KB (1,315 words) - 00:43, 16 May 2024
- IO y -> y w (IO x) >> (IO y) = IO $ \ w -> x w `seq` y w8 KB (1,141 words) - 01:44, 14 July 2021
- ...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 auto11 KB (1,679 words) - 06:20, 11 June 2023
- (y,m,d) = toGregorian $ utctDay c --> (2009,4,21)2 KB (224 words) - 21:06, 6 January 2019
- 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
- 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
- toElems (x, y) = (elems x, y)5 KB (743 words) - 13:10, 9 May 2017
- , Run Date "%a %b %_d %Y %H:%M:%S" "date" 102 KB (189 words) - 01:17, 9 April 2021
- 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
- foldr (\a ~(x,y) -> (a:y,x)) ([],[]) diff xl@(x:xs) yl@(y:ys) | x < y = x:diff xs yl12 KB (1,704 words) - 17:53, 22 November 2019
- 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
- ...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
- f !x !y = x + y [ (x,y) | x <- [1..10], y <- ['a'..'z'] ]22 KB (3,350 words) - 04:31, 8 June 2023
- 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
- square x # lw y # scale s Absolute: (y * w) / (s * x)10 KB (1,576 words) - 22:57, 30 November 2013
- force y = let Just x = y20 KB (3,325 words) - 12:02, 19 April 2024
- :<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
- y <- pure (x+1) <|> pure (x-1) return (x, y)12 KB (2,067 words) - 05:43, 9 March 2021
- getNext >>= \y -> y <- getNext7 KB (1,055 words) - 15:06, 21 December 2018
- ...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
- score guess answer = foldr (\(a,b) y -> if a == b then y+1 else y) 0 where choose x [y] = intToDigit y15 KB (2,018 words) - 01:29, 26 April 2021
- 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
- + 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
- mergeP xs@(Crowd (x:xt)) ys@(VIP y yt) = case compare x y of GT -> VIP y $ mergeP xs yt18 KB (2,583 words) - 20:08, 19 December 2020
- data Less class Cmp x y c | x y -> c8 KB (1,365 words) - 19:23, 15 August 2019
- Note: You can make this a little less painful by factoring out the to be accessed, so maybe you end up writing less boilerplate overall10 KB (1,542 words) - 05:40, 8 June 2023
- {{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
- 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
- -- 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
- 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
- (x:xs) === (y:ys) = True3 KB (170 words) - 23:05, 29 June 2021
- ...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*y16 KB (2,235 words) - 10:26, 29 March 2019
- 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
- stringToTree (x:xs@(y:ys)) | y == '^' = Node x []7 KB (1,025 words) - 02:14, 23 July 2021
- - 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
- g' x y = run (g x) y6 KB (1,053 words) - 03:27, 9 April 2021
- 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
- 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
- ...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 pattern: "X(.?){0,}Y" Regex pattern: "X(.?){1,}Y"26 KB (3,619 words) - 03:30, 10 March 2017
- where bind3 f x y z = join (liftA3 f x y z)7 KB (1,033 words) - 01:16, 27 September 2021
- ...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, t16 KB (2,628 words) - 21:19, 16 December 2022
- ...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
- y <- squares lift $ print (x,y)13 KB (2,036 words) - 13:54, 4 July 2023
- ...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
- cyclic = let x = 0 : y y = 1 : x24 KB (3,850 words) - 17:16, 28 June 2021
- | Ctrl-y |C-y9 KB (1,413 words) - 00:17, 24 November 2014
- :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
- > packages i = foldl1 (\x y -> x ++ " " ++ y) (map showPackage (packageDeps i))7 KB (998 words) - 12:32, 2 October 2020
- *[[Humor/Y-agra|Need help performing?]]5 KB (667 words) - 22:52, 1 May 2024
- !y = k x u2 in in y11 KB (1,628 words) - 10:36, 5 April 2024
- Prelude> let y = x + 3 Prelude> :t y41 KB (6,592 words) - 22:27, 3 May 2024
- yv <- readTVar y yv <- readTVar y;24 KB (3,463 words) - 05:20, 12 July 2021
- g x = let Just y = f x in h y, Irrefutable pattern failed for pattern Data.Maybe.Just y9 KB (1,453 words) - 19:18, 3 February 2021
- delta (Sym y) x | x == y = Unit22 KB (3,425 words) - 22:34, 29 June 2021
- \begin{tikzpicture}[x=1ex,y=1ex]<br/>3 KB (488 words) - 16:11, 3 August 2013
- ifThenElse False _ y = y9 KB (1,503 words) - 13:55, 15 December 2019
- -- 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
- test2 = TestCase (do (x,y) <- partA 3 b <- partB y23 KB (3,542 words) - 03:11, 15 May 2020
- clock = textClockNew Nothing "%Y-%m-%d %H:%M" 14 KB (452 words) - 14:23, 2 May 2018
- raise x (y:ys) = x+y : raise x ys y:ys <- tails xs29 KB (4,702 words) - 12:36, 4 May 2021
- ...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. -- RemiTurk24 KB (4,110 words) - 01:13, 7 November 2020
- where map_one (x:xs) y = (xs, g y x)11 KB (1,895 words) - 19:00, 18 May 2020
- coord (FloatPoint x y) = (x,y) coord (IntPoint x y) = (realToFrac x, realToFrac y)30 KB (4,685 words) - 01:34, 14 July 2021
- ...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
- substitute x y = Wrp (unsafeCoerce x::t2) substitute x y = Wrp (unsafeCoerce x::t2)28 KB (3,716 words) - 13:01, 20 October 2017
- 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 the61 KB (8,858 words) - 11:47, 5 November 2020
- ...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
- * <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 impor25 KB (3,873 words) - 11:08, 6 March 2023
- > My intention is to generate 50 random coordinates like (x,y).5 KB (787 words) - 11:02, 26 December 2017
- ...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 evalua4 KB (637 words) - 02:02, 6 May 2024
- * [http://www.onebadseed.com/blog/?p=51 Don't need the Y combinator]9 KB (903 words) - 07:20, 16 April 2020
- ghci> let y = Repa.map (^2) x ghci> y Repa.! (Z :. 0 :. 2)37 KB (5,672 words) - 07:28, 10 August 2022
- ...tate Y. Do some arbitrarily chosen part-testcases begining with that state Y.""8 KB (1,326 words) - 20:19, 28 September 2014
- #define mouse_trafo(y,x,to_screen) wmouse_trafo(stdscr,y,x,to_screen)13 KB (1,967 words) - 16:07, 9 August 2016
- GHC allows this constructor-less version (with EmptyDataDecls): > y <- c_Foo(x)16 KB (2,449 words) - 17:06, 17 April 2017
- #### liftM2 is just short for do { x <- act1; y <- act2; return (x `op` y) }10 KB (1,520 words) - 07:20, 10 November 2020
- , Assign y (IntConst 7) , Assign p ( BinExpr Add (Var p) (Var y) )28 KB (3,540 words) - 18:19, 5 January 2015
- class HBool b => TypeEq x y b | x y -> b15 KB (2,199 words) - 00:32, 23 May 2017
- ...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
- ...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
- sudo aptitude install binutils-gold -y ...gtkimageview-dev libpoppler-glib-dev poppler-data libtagc0-dev libvte-dev -y12 KB (1,458 words) - 02:36, 26 April 2021
- 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)monomorphism35 KB (5,673 words) - 20:05, 7 July 2015
- 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
- ...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
- mischief x = let y = 141421 * x y20 KB (3,555 words) - 06:05, 24 April 2024
- let printLine a y = mapM (\x -> readBoard a (x,y)) [1..9] >>= mapM_ (putStr . show) in do67 KB (9,593 words) - 05:40, 9 March 2021
- unify x y | x == y = x17 KB (2,482 words) - 20:34, 8 June 2017
- ...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
- 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
- ,'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
- "(function(x,y){return (x - (x % y))/y;})(exprEval(a),exprEval(b));"21 KB (3,466 words) - 15:19, 6 February 2021
- .... 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
- ...orresponding to <i>n (log n)<sup>2</sup> log log n</i> complexity, more or less, in ''n'' primes produced): minus (x:xs) (y:ys) = case (compare x y) of58 KB (8,594 words) - 20:34, 6 May 2023
- substitute x y = Wrp (unsafeCoerce x::t2) substitute x y = Wrp (unsafeCoerce x::t2)34 KB (2,180 words) - 13:00, 20 October 2017
- * [[Ce tip are combinatorul Y ?]] 1.5 * [[Ce tip are Y - combinatorul paradoxal ?]]14 KB (1,971 words) - 23:12, 9 April 2021