Search results

Jump to navigation Jump to search

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

View (previous 100 | next 100) (20 | 50 | 100 | 250 | 500)

Retrieved from "https://wiki.haskell.org/Special:Search"