Search results

instance (Applicative m) => Applicative (ReaderT r m) where ... instance (Alternative m) => Alternative (ReaderT r m) where ...

countLeaves (Branch _ l r) = countLeaves l + countLeaves r

foldl :: (a -> x -> r) -> a -> [x] -> r foldl :: (a -> x -> r) -> a -> [x] -> r

atLevel (Branch v l r) n | n > 1 = atlevel l (n-1) ++ atlevel r (n-1)

go mgu (Var l) r | not (r `contains` Var l) = Just $ (l, r) : mgu go mgu l (Var r) | not (l `contains` Var r) = Just $ (r, l) : mgu

layoutAux x y sep (Branch a l r) = (layoutAux (x+sep) (y+1) (sep `div` 2) r)

preorder (Branch x l r) = x : preorder l ++ preorder r inorder (Branch x l r) = inorder l ++ x : inorder r

So <hask>r = render ["fr", "pt"]</hask> will do the right thing. You just need to pass this <hask>r</hask> around in your code.

add x t@(Branch y l r) = case compare x y of LT -> Branch y (add x l) r

<hask>L-T-R</hask> gives * <hask> (show L) ++ (show T ++ (show R)) </hask>

f (1, x) r = x : r f (k, x) r = x : f (k-1, x) r

f x r a@(Just q) | x == q = r a f x r _ = x : r (Just x)

new = fmap (\r -> Cons (writeIORef r) (readIORef r)) . newIORef new = fmap (\r -> Cons (writeSTRef r) (readSTRef r)) . newSTRef

Or using the slightly more verbose (w.r.t. <hask>(&&&)</hask>) Applicative combinators: f x r (Just a@(i,q)) | x == q = r (Just (i+1,q))

Given a binary tree as the usual Prolog term t(X,L,R) (or nil). As a preparation for drawing the tree, a layout algorithm is req layoutAux x y (Branch a l r) = (Branch (a, (x',y)) l' r', x'')

hbaltree x h = [Branch x l r | l <- hbaltree x hl, r <- hbaltree x hr]

leaves' (Branch _ l r) xs = leaves' l $ leaves' r xs

insert k v (IMap xs) = insert' $ viewl r (l,r) = split (>= Key k undefined) xs

diff_select' n xs = do r <- randomRIO (0,(length xs)-1) let remaining = take r xs ++ drop (r+1) xs

reverseTree (Branch x l r) = Branch x (reverseTree r) (reverseTree l)

...<code>Bool</code>, for instance. Then a function of type <code>(t -> r) -> r</code>, is like a box which takes a question about a value of type <code>t< newtype Cont r t = Cont ((t -> r) -> r)

cbalTree n = let (q, r) = (n - 1) `quotRem` 2 in [Branch 'x' left right | i <- [q .. q + r],

range l r = scanl (+) l (replicate (l - r) 1) range l r = scanl op l $ replicate diff 1

removeAt k (x:xs) = let (a, r) = removeAt (k - 1) xs in (a, x:r) removeAt n (x:xs) = (l, x:r)

where (l, t', r) = layoutAux x1 1 t layoutAux x y (Branch a l r) = (ll', Branch (a, (x,y)) l' r', rr')

...internals' (Branch x l r) xs = (x :) $ internals' l $ internals' r xs

...this string representation, if the tree is given as usual (as nil or t(X,L,R) term). Then write a predicate which does this inverse; i.e. given the stri treeToString (Branch x l r) =

...20). Below, I set up the array <hask>r</hask> for exactly that, with <hask>r!0</hask> forced to <hask>True</hask> to bootstrap the whole thing. buyable n = r!n

<br /><hask>u :: Empty -> r</hask> <br /><hask>u :: r -> ()</hask>

symmetric (Branch _ l r) = mirror l r

...en2 -bg '#324c80' -fg '#adbadd' -e '' -ta l -w 400 -fn '-misc-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*'" ...| dzen2 -e '' -x 400 -w 880 -ta r -fg $FG -bg $BG -fn '-misc-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*' &

Left l, Right r -> l + r ModDur (Tempo r) d -> d / r

filled (Branch _ l r) = [True] : zipWith (++) (filled l) (filled r)... (r, xss'') = cbt xss'

foldr (\p r -> p*p > n || ((n `rem` p) /= 0 && r)) | r == 0 = p : go q ps

uncompress t x = let (r,_) = runState (bar t) x in r do r <- baz

countNodes (Branch _ l r) = countNodes l + countNodes r + 1 baltree h n = [Branch x l r |

where rand = do r <- randomRIO (0, (length xs) - 1) return (xs!!r)

r x = fromJust . find ((== x) . snd) $ t putStrLn . unwords . map fst . head . sort . map (sort . map r) . sol $ n

class Resturi r where x :: r -> r

...ient function phi(m) is defined as the number of positive integers r (1 <= r < m) that are coprime to m.

...bject <math>A</math> of <math>\mathcal{C}</math> to <math>R^{\mathcal{C}(A,R)}</math> corresponding to the CPS monad in Haskell.

tree2ds (Branch x l r) = x:(tree2ds l ++ tree2ds r)

| y == x = let (f,r) = getReps ys in (y:f, r)

rec p <- newIORef (Node 0 r) r <- newIORef (Node 1 p)

newtype ContT r m a ...type <hask>a</hask> and a final result of type <hask>r</hask>. The <hask>r</hask> type can be polymorphic most of the time. You only need to specify

*<code>C-c C-r</code> reload current Haskell interpreter session ...>C-c C-l</code> to load the file. Then, you can go on to type <code>C-c C-r</code> (or simply <code>C-c C-l</code> again) to reload the current module

ChurchList { runList :: forall r. (a -> r -> r) -> r -> r }

f :: forall %r. () -> () -> Int %r Remember that the <hask>forall %r</hask> at the front of the type is supposed to indicate that the return val

instance ParseTree ('Down c ': 'Up ': r) ('Node c '[]) r instance ParseForest ('Down d ': is) (t ': ts) r

= do r <- getStdRandom (randomR (1,prob)) let curr' = if r == 1 then orig else (next:curr)

:* LSE = <code>(\(!_) -> r) (part u)</code> :* RSE = <code>(\(!_) -> r) u</code>

Right r -> case runDRMonad (f r) s' of type MCPS a = forall r. Cont (M r) a

| r == 0 = p : pf ps q where (q, r) = n `divMod` p

regular n k | r == 1 || n <= k || n < 0 || k < 0 = [] (q, r) = (n * k) `quotRem` 2

regexBool r l = l =~ r :: Bool -- simple boolean regex matching

where helper left right@(r:rs) n | otherwise = helper (r:left) rs (n - 1)

lift2 :: (a -> b -> r) -> (Pair a -> Pair b -> Pair r) ...adFix</hask> and <hask>MonadReader</hask> instance for the type <hask>(->) r</hask>. The <hask>liftM</hask> (see below) functions of this [[monad]] are

data Cxt a = Top | L (Cxt a) (Tree a) | R (Tree a) (Cxt a) ...was <code>t</code> and whose parent had context <code>c</code>. The <code>R</code> constructor is similar. <code>Top</code> represents the top of a tre

...this way we can create instances such as <hask> Forall r Show => Show (Rec r) </hask>. This is available to the application programmer as well. ...h corresponding label) to existing records. Suppose we have a record <hask>r = { x = 0, y = 0 }</hask>. If we have an extensible record system we can th

foldr (\p r -> p*p > k || k `rem` p /= 0 && r)

, Run Com "uname" ["-s","-r"] "" 36000

1:p:candidates = [6*k+r | k <- [0..], r <- [1,5]] roll (Wheel n rs) = [n*k+r | k <- [0..], r <- rs]

depth (Node _ l r) = 1 + max (depth l) (depth r) ...<hask>_</hask>). The left branch is named <hask>l</hask>, the right <hask>r</hask>, allowing us to use these values in the right hand side.

==R==

<haskell>(forall a. (t a -> r)) ≅ ((exists a. t a) -> r)</haskell> perimeter (Circle r) = 2 * pi * r

: hold-sell dup float+ f@ close f@ f* deposit >r 0e r> f! ; ( addr -- )

== N-R ==

r <- liftIO (newIORef 0) (next r `mplus` next r >> next r `mplus` next r) >> next r `mplus` next r

Success r >>= k = k r catch (Success r) _ = Success r

idCPS :: a -> (a -> r) -> r mysqrtCPS :: a -> (a -> r) -> r

...rep1&type=pdf Performing Lisp Analysis of the FANNKUCH Benchmark], Kenneth R. Anderson and Duane Rettig (27KB PDF) (# s, r# #) -> case setcount c# r# s of

* /r/haskell

cont r n d = m : rest m = (truncate (sqrt (fromIntegral r)) + n) `div` d

instance MonadExit e (ReaderT r (Exit e)) where instance Monad m => MonadExit e (ReaderT r (ExitT e m)) where

showresp r doc body = case r of

> type R = Other R0 > testS = eval (bot :: S P Q R) :: App (App P R) (App Q R)

snap v origin step = if r==0 then v else v+(step-r) where r = rem (v-origin) step -- NB: origin <= v ; else use MOD

arc(u,r). digraph([r,s,t,u,v],[a(s,r),a(s,u),a(u,r),a(u,s),a(v,u)])

instance (MonadRandom m) => MonadRandom (ReaderT r m) where instance (MonadReader r m, RandomGen g) => MonadReader r (RandT g m) where

runUO g = let !(# _, r #) = runRW# (useUO# (g . UO)) in r !r = g h

diff -r cdaa1062e534 config.h diff -r cdaa1062e534 config.mk

check (Node i l r) = i + check l - check r check (Node i l r) = i + check l - check r

, Run Com "uname" ["-s","-r"] "" 36000

showsEquation (l, r) = showsExprPrec 0 l . showString " = " . showsExprPrec 0 r

?- remove_at(X,[a,b,c,d],2,R). R = [a,c,d]

putStr $ unlines [ "Starting thread for range " ++ show r | r <- ranges ]

...xK_i), raiseMaybe (runInTerm "-title Irssi" "sh -c 'screen -A -r irssi'") (title ~? "Irssi")) ...xK_r), raiseMaybe (runInTerm "-title rtorrent" "sh -c 'screen -A -r rtorrent'") (title =? "rtorrent"))

minus (lft@(CharCount c1 i1):xs) r@((CharCount c2 i2):ys) | (c1 < c2) = do rem <- xs `minus` r

> Right r -> r > Right r -> return r

*** A set <math>R</math> *** A unary operation <math>- : R \to R</math>

...gular expressions where not applicable for this task, e.g. they used other r.e. grammars or ...ng ''w'' is a word of a given regular set (given by a regular expression ''r'')

> instance AddHyp (Gamma ((T2T t) :*: hs)) r gamma > => AddHyp (Gamma hs) (t :*: r) gamma where

nfibs n = let r = replicate (n-1) 0 ++ 1 : 1 : zipWith ((-).(2*)) (drop n r) r in r

| [[Programming performance/KrassiVanguelov R]] | R

-- r and a natural number k, the decimal expansion of r^k terminates if -- and only if the decimal expansion of r does.

# <tt>chmod -R go-rwx /home/newuser</tt>

justDoc (Just (d,r,x)) = stripResult (fromJSON x) justDoc (Just (d,r,x)) = stripResult (fromJSON x)

-- Another argument, tagged with R because it is :*: M1 S NoSelector (K1 R (UserTree a))

...epository.readscheme.org/ftp/papers/sw2004/shan.pdf</ref>; moreover, <ref> R. Kent Dybvig, Simon Peyton-Jones, and Amr Sabry. "A Monadic Framework for -- i.e the "rest" of the computation, to a final result of type r.

serialize (Branch l r) = [(x, '1':code) | (x, code) <- serialize r]

-- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3

naturals r n = ((naturals $! r2) $! (n+r))

...ient function phi(m) is defined as the number of positive integers r (1 <= r < m) that are coprime to m. Example: m = 10: r = 1,3,7,9; thus phi(m) = 4. Note the special case: phi(1) = 1.

splitAts = foldr (\n r -> splitAt n >>> second r >>> uncurry (:)) return -- "abracadabra" -> fromList [('a',5),('b',2),('c',1),('d',1),('r',2)]

data Was = R|L|U|D|F|B data Is = R|L|U|D|F|B

| otherwise = do r <- rs let b' = if c `elem` r then i:b else b]

"NOTICE AUTH :*** Looking up your hostname...\r\nNOTICE AUTH :*** Checking ident\r\nNOTICE AUTH :*** Found your hostname\r\n ...

* Subreddit [https://www.reddit.com/r/ruhaskell /r/ruhaskell]

...Scaife N. Hammond K. Horiguchi S. Klusik U. Loogen R. Michaelson G.J. Pena R. Priebe S. Trinder P.W. Higher-order and Symbolic Computation 16(3) (2003) :Trinder P.W. Loidl H-W. Pointon R.F. Journal of Functional Programming 12(4&5) (2002), pp 469-510.

R:

tuples r l | r == 1 = [[el] | el <- l]

* [https://www.reddit.com/r/haskell/ /r/haskell] * [https://www.reddit.com/r/haskellgamedev /r/haskellgamedev]

:<math>\underline\mathbf R^m : \left\lfloor m\right\rfloor \times \left\lfloor m+2\right\rfloor \to \l :<math>\underline\mathbf R^m f h = g\;\mathrm{where}</math>

Given a binary tree as the usual Prolog term t(X,L,R) (or nil). As a preparation for drawing the tree, a layout algorithm is req ...this string representation, if the tree is given as usual (as nil or t(X,L,R) term). Then write a predicate which does this inverse; i.e. given the stri

-- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3

r <- listOf' $ elements chars_rest return (s:r)

...nlineIO <code>unsafeInlineIO</code>], also known as [http://www.reddit.com/r/haskell/comments/2cbgpz/flee_traveller_flee_or_you_will_be_corrupted_and/ < accursedUnutterablePerformIO (IO m) = case m realWorld# of (# _, r #) -&gt; r</pre>

import qualified Data.Array.Repa as R extent :: (Shape sh, Source r e) => Array r sh e -> sh

-- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3

...ness on Parallelism and the Limits of Strictness Analysis" (G. Tremblay G. R. Gao) http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.36.3806

| SysCallName p1 p2 ... pn (r -> IO a) * and <code>r</code> is the result of the system call.

-- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3

* Benedict R. Gaster, Mark P. Jones: [http://web.cecs.pdx.edu/~mpj/pubs/polyrec.html A P

...e and paid accounts. Among the many tools it provides (including SageMath, R, Jupyter, Numpy/Scipy/Matplotlib, Octave, Cython, GAP, Pari, Macaulay2, and

insert b (Branch a l r) | b < a = Branch a (insert b l) r

let color3f r g b = color $ Color3 r g (b :: GLfloat)

putStr reason >> putStr "\r\n" putStr "\r\n"

sphere c r = SolidItem (Sphere c r (1.0/r))

...Novatec Editora Ltda.], 2006, 296 pages, ISBN 85-7522-095-0. The price is R$ 62,00 (in Reais). Language: Portugese

("R","2D2")

-- mod-{w,e,r} %! Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r} %! Move client to screen 1, 2, or 3

r <- getScreenRes ":0" 0 --display ":0", screen 0 topLeftBar <- dzenSpawnPipe $ dzenTopLeftFlags r

libbzip2 is the library written by Julian R Seward used in bzip2(1) together with a string which can be ``r'' for read mode or ``w'' for

:R. F. C. Walters. Cambridge Computer Science Texts, 1991, 176 pages. ISBN 0-5

...ngs of the Workshop on Graph Reduction, Santa Fe, New Mexico, J. Fasel and R. Keller, editors, Springer-Verlag, October 1986. ...emy Gibbons (1993). In LNCS 669: Mathematics of Program Construction, ed. R. S. Bird, C. C. Morgan and J. C. P. Woodcock, Springer-Verlag, p. 122-138.

-- mod-{w,e,r} %! Switch to physical/Xinerama screens 1, 2, or 3 -- mod-shift-{w,e,r} %! Move client to screen 1, 2, or 3

|C-r |R

...R. E. Jones, J. Kamperman, P. Lee, X. Leroy, R. D. Lins, S. Loosemore, N. R&ouml;jemo, M. Serrano, J.-P. Talpin, J. Thackray, S. Thomas, P. Walters, P.

fmap f (Node l x r) = Node (fmap f l) (f x) (fmap f r) | Star RegExp -- r* (Kleene star); matches r zero or more times

tuples (r+1) xs = do (y:) `fmap` tuples r ys

,'O'),((3,3),'P'),((4,3),'P'),((5,3),'Y'),((3,5),'A'),((4,5),'R'),((5,5),'E'),((

sieve (x:xs) t@((q:cs):r) | otherwise = sieve (minus xs cs) r

:Haskell interface to R

let r = BG.runBitGet flags (do case r of

...make it non-exhaustive, add a case statement to solve' in order to check "r" and branch on the result. r <- solve a (x+1,y)

Ant Al'Thor R. <ant (at) theixo (dot) com> (AI Interest & Business) * [https://patch-tag.com/r/alpmestan/hasklab/wiki/ HaskLab Wiki]

Config { font = "-*-Fixed-Bold-R-Normal-*-13-*-*-*-*-*-*-*" Config { font = "-*-Fixed-Bold-R-Normal-*-13-*-*-*-*-*-*-*"

*<b>R:</b>[http://www.reid-consulting-uk.ltd.uk/alastair/ Alastair Reid], Reid Co

SM c1 >>= fc2 = SM (\s0 -> let (r,s1) = c1 s0 SM c2 = fc2 r

* R. F. C. Walters: [http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=0

> ld -r -m elf_i386 -o module.ko hsHello_stub.o hsHello.o module.mod.o hello.o *.a

| Lilypond back-end || Jeffrey R. Lewis || A back-end for Haskore to produce Lilypond notation files.

#sudo dpkg -r package

# E. Meijer, M. Fokkinga, R. Paterson, [http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf

:Nancy A. Day, Jeffrey R. Lewis and Byron Cook. CHARME'99. September 1999.

...omes first. That's easy to check: just put your point between the 'f' and 'r' of 'foldr' and hit C-c C-t RET. The type of foldr will be revealed in the

Then taking the inverse corresponds to a L-R reflection, and taking the transpose corresponds to a U-D reflection. Give

-- Win+R open the Gnome run dialog

...Windows. '''CONS:''' Poor alignment support (though [http://www.reddit.com/r/haskell/comments/ts8fi/haskell_ides_emacs_vim_and_sublime_oh_my_opinions/c4 :* Sometimes the highlighting gets confused. Then it might help to press Ctrl+R and re-colour the editor.

...liftIO</hask> is needed because our handler runs inside some <hask>ReaderT r IO</hask> monad but <hask>mainQuit</hask> is just <hask>IO</hask>.

let r = map processIt (lines s) putStr (unlines r)

;[ftp://ftp.ida.liu.se/pub/publications/techrep/1996/r-96-23.ps.gz The evaluation dependence tree: an execution record for lazy fu :Henrik Nilsson and Jan Sparud. Research Report LiTH-IDA-R-96-23, Department of Computer and Information Science, Linkpings universite

# the ((->) r) monad

.../hackage.haskell.org/package/Rlang-QQ Rlang-QQ is a quasiquoter for inline R]

f x y = let r = expensive x in r+y

...lers.markerfile -night 30 -mag 10 -label -font "-*-lucidatypewriter-medium-r-normal-*-*-100-75-75-m-*-iso8859-1"</nowiki></pre>

getYoungerThan limit db = mapMaybe (\r -> do { guard (age r < limit); return r }) db try f = catch (do r <- f

cosh r = (exp r + 1/exp r)/2 cosh r = (x + 1/x)/2 where x = exp r

case (my_primop# x y s) of (# s1, r #) -> (# s1, I64# r #)

* [http://recipes.gobolinux.org/r/?list=XMonad Gobo] ...switches the focus between screens, while pressing '''<code>shift-mod-{w,e,r}</code>''' moves the current window to that screen. When xmonad starts, wor

:R Hinze, J Jeuring - lecture notes of the Summer School on Generic Programmin

reify = \(Just r) -> appE r $ conE $ last args

Ömer S. Ağacan and Ryan R. Newton (Indiana University)

*: Rob R. Hoogerwoord. (Hoogerwoord's [https://venus.tue.nl/ep-cgi/ep_publ.opl?taal=

f (l,r) = l + r

...and. I would recommend using an editor in a separate terminal, and using :r to reload, but :e can still be useful for quick edits from within GHCi.

:R. Matthes, T. Uustalu. Theor. Comput. Sci., v. 327, n. 1-2, pp. 155-174, 2

...ric.Probability.Visualize contains a wrapper to [http://www.r-project.org/ R]

$ cp -R ./dist/doc/html/haq/ haq-0.0-docs

Prelude> :r

Prelude> :r liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r

...y physical ordering rather than ScreenID. (I.e. no more rebinding mod-{w,e,r} because xorg chose 0:middle, 1:right, 2:left, etc.)

:Benedict R. Gaster and Mark P. Jones. Department of Computer Science, University of No :François Pottier and Yann Régis-Gianas, 2006

...te</code>—including <code>MaybeT (State s)</code>, <code>StateT s (ReaderT r IO)</code>, and so on. Similar type classes exist for <code>Reader</code>, ...ce of <code>Monoid</code> to do some clever things ([http://www.reddit.com/r/programming/comments/7cf4r/monoids_in_my_programming_language/c06adnx examp

<shapr> Det kapitel `Type-indexed data types' &#228;r grunded av det artikel med samma namn. <nowiki>*</nowiki> autrijus stares at type Eval x = forall r. ContT r (ReaderT x IO) (ReaderT x IO x) and feels very lost

...and implementation of an operating system in a functional language], John R. G. Cupitt (page 10 of 150).</small><!-- 1989 --> ...model for I/O in equational languages with don’t care non-determinism], H. R. Walters and J. F. Th. Kamperman (page 14 of 15).</small><!-- 1995 -->

...skell.org/Întrebarile_incepatorului Întrebările începătorului]. Am adăugat răspunsuri noi (dec. 2009-16 ian. 2010). Înformațiile pentru studenți sun Un răspuns la întrebarea „Ce este Haskell și la ce ne-a folosit și ne folo

...ar fi sunat ca intr-un serial de desene animate, mai ales daca-l uitam, pe R. Asa ca am schimbat ordinea. E drept ca nu e un nume inspirat ales, deoarec

* 2006-10 [http://www.reddit.com/r/programming/comments/ox6s/ask_reddit_what_the_hell_are_monads/coxiv Ask Red * 2008-01 [http://www.reddit.com/r/programming/comments/64th1/monads_in_python_in_production_code_you_can_and/

significant = not . all (`elem` " \n\r\t")

<b>Course:</b> Programmering för Naturvetare<br> <b>Materials:</b> Hugs; R. Bird "Introd. to FP using Haskell" (2nd Ed), J. E. Labra Gayo. "Introducti

...Novatec Editora Ltda.], 2006, 296 pages, ISBN 85-7522-095-0. The price is R$ 62,00 (in Reais). Language: Portuguese ...en Haskell à l'usage de l'étudiant et du développeur], 264 pages, Ellipses Références sciences, 2019, French, ISBN: 9782340028777