Hugh Perkins wrote:
Is reflection hard in Haskell? In C# its easy, and its one of the most
powerful features of C#
That's another way of saying that the truly powerful features are
missing from C#...
Yes, but I'm kindof stuck giving useful input to makeConstrM, so if
anyone has any ideas?
Roberto Zunino wrote:
Floating out (newBuffer defaultSize) as in
| foo = newBuffer defaultSize
|
| toLazyByteString m = S.LPS $ inlinePerformIO $ do
| buf - foo
| return (runBuilder (m `append` flush) (const []) buf)
would still be safe, AFAICS. Floating out buf instead should
Greetings,
I was trying to understand the magic inside Data.Binary, and found two
somewhat suspicious uses of inlinePerformIO, which imho has a far too
innocuous name:
| toLazyByteString :: Builder - L.ByteString
| toLazyByteString m = S.LPS $ inlinePerformIO $ do
| buf - newBuffer
Andrew Coppin wrote:
Note that the challenge asks for the internal bitmap representation of
an IEEE double-precision integer
Actually it didn't. It asked for the machine's internal representation
of a double precision float, and you are not guaranteed that this
representation conforms to IEEE
Eric wrote:
(1) Have Handlers implement a method handle(m: Msg). To add new types of
message, we declare message types which extend Msg. The Handler then
uses runtime type testing to decide how to deal with each message. The
advantage of this design is that we can add new Handler and new
Albert Y. C. Lai wrote:
I say Excel is a functional language. If there needs to be the quoted
distinction, fine: Excel the language is a functional language, and
Excel the application is an interpreter of said language.
Excel has functions, but does it treat functions as it treats other
Pete Kazmier wrote:
train:: [B.ByteString] - WordFreq
train words = frequencyMap
where
frequencyMap = foldr incWordCount M.empty words
incWordCount w m = M.insertWith (+) w 1 m
So is 'incWordCount' strict in its second argument? I'm still not
sure exactly
Bryan O'Sullivan wrote:
Udo Stenzel wrote:
There is another bug of this sort in your code. Consider
incWordCount w m = M.insertWith (+) w 1 m
There is no reason to evaluate the sum inside the map, instead an
unevaluated thunk is put in there.
Would not Data.Map.insertWith
kynn wrote:
(I don't need elegant
factorial or Fibonacci functions in my everyday work.)
I think you do. Most of your utility programs probably fit into the
simple frame of
main = interact $ unlines . map f . lines
for suitable f. Of course, f is hardly ever the factorial function, but
it
Sergey Perminov wrote:
I wished to get output of unix commands in haskell code.
So i wrote:
--
import System.IO
import System.Process
eval :: String - IO String
eval s = do (_,hOutput,_,hProcess) -
Leandro Penz wrote:
buildStuff =
func1 ++ func2 ++ func3 ++ func4
My idea is to have a monad with a concatenating , so that I can:
bulidStuff = do
func1
func2
func3
func4
buildStuff = concat [
func1,
func2,
func3,
func4 ]
Remember, functional
Alex Queiroz wrote:
I don't quite get how ($!) works. I have this function:
ids - liftM (map fromSql . concat ) $! quickQuery con query []
There's a difference between an IO action and the result of said action,
and similarly there's a difference between making sure an action is
Neil Mitchell wrote:
As others have said though, I wouldn't worry overly about it. The
whole concept of static linking being wrong, but dynamic linking being
fine, when you can flip between the modes just by changing compiler,
is just silly. You don't infringe (or uninfringe) copyright with a
Benjamin Franksen wrote:
Udo Stenzel wrote:
Sure, you're right, everything flowing in the same direction is usually
nicer, and in central Europe, that order is from the left to the right.
What a shame that the Haskell gods chose to give the arguments to (.)
and ($) the wrong order
J. Garrett Morris wrote:
On 2/4/07, Udo Stenzel [EMAIL PROTECTED] wrote:
exists s wmap = isJust $ Map.lookup (sort s) wmap = find (== s) . snd
If you're going to write it all on one line, I prefer to keep things
going the same direction:
Hey, doing it this way saved me a full two
John Ky wrote:
On 1/25/07, BBrraannddoonn SS.. AAllllbbeerryy
KKFF88NNHH [EMAIL PROTECTED] wrote:
I'm probably missing something, but:
(a) Why not:
data ANode = Branch { name :: String, description :: String,
children :: [AnyNode] }
Yitzchak Gale wrote:
You're right, it is not in the docs. I don't think anyone would
have planned it that way. StateT is strict only because there
happens to be a line in a do-expression that looks like:
(a, s') - runStateT m s
The tuple pattern-match causes the strictness.
Ross Paterson wrote:
This (like StateT) gives you strictness in the pair, but doesn't give
the strictness in the state that the original poster wanted.
I think the OP wanted both. If State is lazy in the pair, a long chain
of the form (a = (b = (c = ... = z))) gets build up and blows
the stack
Yitzchak Gale wrote:
Here is a concrete example:
Let's say you want to shuffle a large list randomly,
within a larger application that lives inside some
MTL monad stack. Among other things, your monad
m satisfies (RandomGen g, MonadState g m), perhaps
after a lift.
Well, it turns out
[EMAIL PROTECTED] wrote:
I'm timing the following script.I'm not expert to evaluate th O'ness
of this code, I hope someone can do it. The program clusters n
integers in m buckets based on their distance. Anyway I thing should
be linear.So I timed som executions changing the first arg.
[...]
Yitzchak Gale wrote:
It seems to me that a natural notion of a state transformer
in the ST monad is the type:
STRef s st - ST s a
Are there any useful functions of this type? I guess, your intention is
that this transformer makes no other use of the ST monad than reading
or writing a single
Steve Schafer wrote:
Here's the essence of the problem. If I have this:
process1 x y =
let u = foo x y;
v = bar u;
w = baz v
in w
I can easily rewrite it in point-free style:
process1 = baz . bar . foo
That should have been
process1 = (.) (baz . bar) . foo
Reto Kramer wrote:
What I'm really looking for is not so much the chaining of StateT
compositions, but rather the isolation of StateA from StateB while
they both flow from the search loop into the respective library calls
(foo, bar) transparently to the application programmer.
How about
Alfonso Acosta wrote:
On 12/13/06, Udo Stenzel [EMAIL PROTECTED] wrote:
Finished! Look Ma, no existentials, no Typeable, no wrappers, even the
types have become simple!
I like the fact that type parameters are removed, which makes them
homegeneus and solves the problem of storing them
Alfonso Acosta wrote:
If anyone finds a way of implementing something equivalent to this code
without unsafeCoerce# and ...
* Not changing chooseDesc or finding an equivalent
* Not splitting or changing Descriptor type (I already found an
equivalent way which uses existentials and in
Alfonso Acosta wrote:
I've been using Data.Dynamic but the Typeable requirement doesn't go
well with FFI declarations (which don't accept type contexts).
You wouldn't need a Typeable context anyway; what's biting you is that
Dynamic is not one of the primitive types that can pass across the
TJ wrote:
--
module Global where
import Data.IORef
theGlobalVariable = newIORef []
testIt = do ref - theGlobalVariable
original - readIORef ref
print original
writeIORef ref [1,2,3]
Niko Korhonen wrote:
I have the following code whose purpose is to add dither (noise) to a given
array. The code looks very straightforward but apparently it has a memory leak
somewhere.
No, it doesn't. It can't, because it doesn't even compile. After
correcting the obvious
(lo,
Donald Bruce Stewart wrote:
So how do we help out the beginners, other than warning about fromJust,
and providing a useful error message as we can, for when they just go
ahead and use head anyway?
Kill head and tail right now and provide a safe equivalent? Either
uncons :: [a] - Maybe
jim burton wrote:
I want to split a string into 5 parts of equal length, with the last fifth
padded if necessary, but can't get it right - here's what I've got -
fifths s = unwords.take 5.unfoldr (Just . splitAt l) $ s ++ repeat ' '
where l = (length s + 4) `div` 5
Of course no Haskeller
Andrea Rossato wrote:
Now, the state will not be entirely consumed/evaluated by the user,
and so it will not become garbage. Am I right?
No. The state cannot become garbage, because there is still a reference
to it. As long as runStateT has not returned, any part of the state can
still be
Andrea Rossato wrote:
I did not get an appreciable improvement with performGC, as you can
see from here:
http://gorgias.mine.nu/haskell/a.out.withPerformGC.ps
But I found a solution: just write the opml state component to a file!
Obviously the values in question were not garbage, rather
Vraj Mohan wrote:
my_sqrt :: Float - Float
my_sqrt x = improve 1 x
where improve y x = if abs (y * y - x) epsilon
then y
else improve ((y + (x/y))/ 2) x
epsilon = 0.1
This works for several
Mikael Johansson wrote:
On Tue, 10 Oct 2006, Misha Aizatulin wrote:
Here is an argument against Reply-To munging. I'd say I agree with it:
http://www.unicom.com/pw/reply-to-harmful.html
* It provides no benefit to the user of a reasonable mailer.
[...]
1) get multiple copies of mails
Robert Dockins wrote:
FWIW, I'm using Apple's Mail.app, and it doesn't have a reply-to-
list. In fact, I don't know of a mail client off the top of my head
that does
Mutt does. But that's to be expected, considering that it was written
because the author was fed up with the poor handling of
Yang wrote:
type Poly = [(Int,Int)]
addPoly1 :: Poly - Poly - Poly
addPoly1 p1@(p1h@(p1c,p1d):p1t) p2@(p2h@(p2c,p2d):p2t)
| p1d == p2d = (p1c + p2c, p1d) : addPoly1 p1t p2t
| p1d p2d = p1h : addPoly1 p1t p2
| p1d p2d = p2h : addPoly1 p1 p2t
addPoly1 p1 [] = p1
addPoly1 [] p2 =
Matthias Fischmann wrote:
although this wasn't the original problem, i like it, too :). but now
i am stuck in finding an optimal implementation for lines.
Isn't the obvious one good enough?
lines [] = []
lines s = go s
where
go [] = [[]]
go ('\n':s) = [] : lines s
go (c:s) = let
Daniel Fischer wrote:
Most certainly not. I'm pretty sure this is to a bug in your code.
Something retains a data structure which is actually unneeded. Probably
Apparently. And my money is on a load of lines from the file (of which I need
only the first and last Char).
Then you're
Lemmih wrote:
main = do
args - getArgs
flip mapM_ args $ \arg -
flip mapM_ [1..3] $ \n -
putStrLn $ show n ++ ) ++ arg
Or even:
main = do
args - getArgs
putStr $ unlines [ show n ++ ) ++ arg
| arg - args, n - [1..3] ]
I'm really at a loss
Ketil Malde wrote:
Daniel Fischer [EMAIL PROTECTED] writes:
Maybe I've misused the word segfault.
I think so. A segfault is the operating-system complaining about an
illegal memory access. If you get them from Haskell, it is likely a
bug in the compiler or run-time system (or you were
Daniel Fischer wrote:
The programme consumed more and more memory (according to top),
kswapd started to have a higher CPU-percentage than my programme,
programme died, system yelling 'Speicherzugriffsfehler', top displays
'kswapddefunct'.
I believe that means my programme demanded more
Andrea Rossato wrote:
It seems related to dynamic linking: I created a separated module
(Xml.hs) that imports Text.XML.HaXml and parses a xml string. I then
created a file (xml.hs) that imports Xml and prints name, defined in
Xml.hs. The expected output should be elementTest.
Whatever it is,
Andrea Rossato wrote:
[12:03:[EMAIL PROTECTED]:~/devel/haskell/xml]$ ghci -package HaXml xml1.hs
[logo]
Loading package base-1.0 ... linking ... done.
Loading package haskell98-1.0 ... linking ... done.
Loading package HaXml-1.13.1 ... linking ... done.
Skipping Main ( xml1.hs,
Tamas K Papp wrote:
Is there a way to use NaN and Infinity as literals, or at least to
test if a value is NaN or Infinity?
*Main let nan=0/0
*Main nan
NaN
*Main nan==0/0
False
so storing the value does not work...
Not sure what you mean here. In IEEE floating point, NaN is not equal
John Goerzen wrote:
I have the below program, and I'm trying to run it on an input of about
90MB. It eats RAM like crazy, and I can't figure out why.
wordfreq inp = Map.toList $ foldl' updatemap (Map.empty::Map.Map String Int)
inp
where updatemap nm word = Map.insertWith updatefunc
Bulat Ziganshin wrote:
Data.HashTable may be a faster alternative for Map (if ordering isn't
required)
Or it may not. Finding a good hash function for the words John is
counting, is a challenge itself. Finding a good one that doesn't look
at each character at least once, might be outright
Stephane Bortzmeyer wrote:
I'm trying to use Parsec for a language which have identifiers where
the '-' character is allowed only inside identifiers, not at the start
or the end.
identifier = do
start - letter
rest - many (alphaNum | char '-')
end - letter
return
Lennart Augustsson wrote:
Well, bind is extracting an 'a'. I clearly see a '\ a - ...'; it
getting an 'a' so it can give that to g. Granted, the extraction is
very convoluted, but it's there.
Oh, that can be remedied...
m = g = m . flip g
In fact, why even mention m?
(=) = (. flip)
Benjamin Franksen wrote:
Sure. Your definition of bind (=):
...
applies f to something that it has extracted from m, via deconstructor
unpack, namely a. Thus, your bind implementation must know how to produce
an a from its first argument m.
I still have no idea what you're driving at, but
Julien Oster wrote:
While we're at it: The best thing I could come up for
func2 f g l = filter f (map g l)
is
func2p f g = (filter f) . (map g)
Which isn't exactly point-_free_. Is it possible to reduce that further?
Sure it is:
func2 f g l = filter f (map g l)
func2 f g = (filter
Chris Kuklewicz wrote:
I just tried to mimic regular expression matching with ReadP and got what
seems like a non-terminating program. Is there another way to use ReadP to
do this?
-- Simulate (a?|b+|c*)*d regular expression
test = star (choice [quest (c 'a')
,plus
Andrea Rossato wrote:
Il Mon, Aug 28, 2006 at 09:28:02PM +0100, Brian Hulley ebbe a scrivere:
data Eval_SOI a = SOIE {runSOIE :: State - (a, State, Output, Bool)}
well, I thought that this was not possible:
(=) :: m a - (a - m b) - m b
And you are right. In case of an exception, you don't
Stephane Bortzmeyer wrote:
Parsec provides count n p to run the parser p exactly n times. I'm
looking for a combinator countBetween m n p which will run the
parser between m and n times. It does not exist in Parsec.
infixr 2 :
(:) = ap . ap (return (:))
countBetween 0 0 _ = return []
Andrea Rossato wrote:
this is what I'm trying to do, sort of: turn the code at the button
into the do-notation.[1]
type MSO a = State - (a, State, Output)
mkMSO :: a - MSO a
mkMSO a = \s - (a, s, )
bindMSO :: MSO a - (a - MSO b) - MSO b
bindMSO m f = \x -
let (a, y, s1)
[EMAIL PROTECTED] wrote:
I found a way to remove this space leak, however, I do not really
understand why there was a space leak in the first place. I would
really appreciate any light that could be shed on this.
instance ArrowChoice SF where
left (SF f)
= SF (\xs - combine xs (f [y
Hi Gregory,
Gregory Wright wrote:
step :: Tag s - ST s (Maybe Integer)
step t = do
c - readSTRef (count t)
s - readSTRef (state t)
writeSTRef (count t) (c - 1)
writeSTRef (state t) (nextState s)
if (c = 0) then return Nothing else return (Just c)
Neil Mitchell wrote:
I'm trying to write out a binary file, in particular I want the
following functions:
hPutInt :: Handle - Int - IO ()
hGetInt :: Handle - IO Int
For the purposes of these functions, Int = 32 bits, and its got to
roundtrip - Put then Get must be the same.
How
Szymon Z??bkiewicz wrote:
The compiler tells me thats there's an error on line 10:
The last statement in a 'do' construct must be an expression
I think, you have reached the point where treating do-notation as magic
won't help you. Remember,
do
nr1 - read (prompt enter 1. number: )
Ahn, Ki Yung wrote:
Recently, I'm facing the dark side of laziness
-- the memory leak because of laziness.
Are there standardized approaches for detecting and fixing
these kind of problems?
Not really. As Don S. already said, try heap profiling. The function
that is too lazy will show up
Marc Weber wrote:
I've tried as an exercise to learn how to use the state monad to create
a tree this way:
createTree :: Int - Int - (Tree Int, Int)
createTree 4 = runState $ State $ \s - (Node s [] , s+1) -- stop at level 4
createTree level = runState (do item - State $ (\s - (s,s+1))
Matthias Fischmann wrote:
But if GPL is stuck to any part of the code and
manages to infect the rest, the client can make you sign as many NDAs
as there can be. The GPL still entitles you to sell it.
Nonsense. The GPL says, *if* you distribute a binary, *then* you also
have to distribute the
Matthias Fischmann wrote:
And it's really not as easy to control as you suggest: If you ever
take in a single patch under the GPL,
This kind of thing doesn't happen by accident. Patches don't magically
creep into your code, you have to apply them deliberately and you should
always know whether
Hans van Thiel wrote:
I'm wondering why I can't find any commercial Haskell applications on
the Internet. Is there any reason for this?
Of course. Corporations are conservative to the point of being
boneheaded. So to avoid risk, they all went on the internet and said,
Gee, I can't find any
Martin Percossi wrote:
Paul Hudak wrote:
foo x y = ...
We know that x and y are formal parameters, whereas if they were
capitalized we'd know that they were constructors.
I agree that naming can be abused. But I think it should be *me* ...
Oh, you like to decide lexical ambiguities.
Gabriel Sztorc wrote:
I want to filter a list with a predicate that returns a IO value,
something that filterM is supposed to do. The problem is, filterM
overflows the stack for really big lists
Are you sure it's filterM's fault? Can you post the code in question?
Stack overflows are
Stephane Bortzmeyer wrote:
The first would be to test whether bb is followed by eof or
comma before accepting it.
notFollowedBy actually does the opposite (checking that there are no
more letters).
Are you sure that you don't actually want
* many1 letter `sepBy1` comma
? Just asking,
Stephane Bortzmeyer wrote:
minilang = do
char 'a'
try (optional (do {comma ; char 'b'}))
optional (do {comma ; char 'c'})
eof
return OK
* CUT HERE ***
parse error at (line 1, column 2):
unexpected c
expecting b
Apparently,
Andrew Pimlott wrote:
On Thu, Jul 27, 2006 at 09:59:37PM +0200, Udo Stenzel wrote:
In fact, that's consistent with the current documentation, because
* getFileName foo == foo
* getFileName foo/ ==
I have to disagree with that.
No, you don't. That's the current behaviour of Neil
Andrew Pimlott wrote:
On Wed, Jul 26, 2006 at 05:06:41PM -0400, David Roundy wrote:
This doesn't apply uniformly to all programs--except that we can say
that any path with a trailing '/' is intended to be a directory, and
if it's not, then that's an error.
I thought some more about this,
Andrew Pimlott wrote:
The drive functions stand on their own as a chunk, and are possibly
not well suited to a Posix system, but are critical for a Windows
system.
Why are they critical for portable code? I am fine with
Windows-specific functions, but I think it's a mistake to bundle
Duncan Coutts wrote:
On Wed, 2006-07-26 at 15:29 +0200, Udo Stenzel wrote:
Exactly. I believe, a FilePath should be an algebraic datatype.
We've had this discussion before. The main problem is that all the
current IO functions (readFile, etc) use the FilePath type, which is
just
Andrew Pimlott wrote:
Maybe the trailing slash is important enough to take into account.
No, not the trailing slash. The difference between a directory and its
contents is important enough. This is ususally encoded using a trailing
slash, but I'd rather not worry about that detail in a
Chad Scherrer wrote:
But why should this...
sumArrays [] = error Can't apply sumArrays to an empty list
sumArrays (x:xs) = runSTArray (result x)
where
result x = do x0 - thaw x
mapM_ (x0 +=) xs
return x0
work differently than this...
Johan Grönqvist wrote:
I would like use a list (as stack) that can contain several kinds of values.
data Element = Int Int | Float Float | Func : Machine - Machine | ...
Now I would like to have this type be an instance of the class Show, so
that I can see what the stack contains in
Neil Mitchell wrote:
Or if you don't want to go for a fold next, in a style more similar to
the original:
maximum [] = undefined
maximum [x] = x
maximum (a:b:xs) = maximum (max a b : xs)
It even reproduces the stack overflow, though for a different reason.
Better write it this way:
Bjorn Lisper wrote:
Here is one way to do it. First, you have to interpret operations on
matrices as being elementwise applied. E.g, (*) is interpreted as zipWith
(zipWith (*)) rather than matrix multiply
What's this, the principle of greatest surprise at work? Nonono, (*)
should be matrix
[EMAIL PROTECTED] wrote:
apparently - Clean has better handling of strictness
issues [saying at the same time that he/she doesn't use Clean...]
Uhm... well... and does it? From what I've heard, Clean has the same
mechanism as Haskell, which is the 'seq' primitive. Clean just adds
some
Vladimir Portnykh wrote:
I am trying to define the following types
data MyStringType a = String deriving (Eq, Ord, Show)
data QADouble a = Double deriving (Eq, Ord, Show)
These are not what you think they are. MyStringType has a phantom type
parameter and only one value, which is the
Bjorn Lisper wrote:
- your definition of fromInteger will behave strangely with the elementwise
extended operations, like (+). 1 + [[1,2],[3,4]] will become
[[2,2],[3,5]] rather than [[2,3],[4,5]]. Array languages supporting this
kind of overloading invariably have the second form of
minh thu wrote:
but i consider to move back to c/c++.
I'm led to believe that you just haven't got the hang of the things that
just aren't there in C, such as Monads and higher order functions. So
you cannot yet see what you would miss in C. (And I guess, you're not
feeling at home in C++
[EMAIL PROTECTED] wrote:
I need a functions which takes as argument a list of lists like this one:
[[1,2],[3],[4]]
and gives me a list of list with all the possible combinations like this one:
[[1,3,4],[2,3,4]]
sequence
Finding out why it is named that strangely is left as an
Jacques Carette wrote:
Bulat Ziganshin wrote:
malloc :: Storable a = IO (Ptr a)
malloc = doMalloc undefined
where
doMalloc :: Storable b = b - IO (Ptr b)
doMalloc dummy = mallocBytes (sizeOf dummy)
Is there any reason to not code this as
malloc :: Storable a = IO
Evan Martin wrote:
Here's the beginning of
the file, where it's not obvious to me how to distinguish elements in
the :: section from the rest of the file.
:: Judge: USDP Game: dip Variant: standard
:: Deadline: F1901M Mon 20 Feb 2006 20:00 PST
:: URL:
Jason Dagit wrote:
reserved units. | reserved unit.
I always struggle with when I need to use 'try' with parsec.
My understanding is that if 'unit.' appears in the input the first
parser will parse up to the '.' and then fail and consume the input up
to that point, leaving the
Evan Martin wrote:
Unfortunately, the output is intended to be human-readable, and this
makes parsing it a bit of a pain. Here are some sample lines from its
output:
France: Army Marseilles SUPPORT Army Paris - Burgundy.
Russia: Fleet St Petersburg (south coast) - Gulf of Bothnia.
Eugene Crosser wrote:
Having read Yet another Haskell tutorial (note on p.20), doesn't foldl
have to read the complete list before it can start processing it
(beginning from the last element)? As opposed to foldr that can fetch
elements one by one as they are needed?
Both foldl and foldr
Eugene Crosser wrote:
Anyway, I understand that you used 'seq' in your example as a way to
strictify the function that updates accumulator. Could you (or
anyone) explain (in plain English, preferably:) the reason why 'seq' is
the way it is. In the first place, why does it have the first
Eugene Crosser wrote:
This is my program:
module Main where
import Data.Map
main = printMax . (foldr processLine empty) . lines = getContents
processLine line map = insertWith (\new old - new + old) line 1 map
printMax map = putStrLn $ show $ foldWithKey
(\key val accum - if
Ben Rudiak-Gould wrote:
My reaction to this thread is the same as Donn Cave's: even after reading
through the whole thread, I don't understand what a Haskell shell is
supposed to be.
I'd like one as a scripting environment, a bit like scsh, just strongly
typed and easier on the eyes.
Brian Hulley wrote:
In C++, STL provides a vector class which behaves as an array except you
can insert/delete elements from it.
Though you shouldn't. If you constantly insert and delete in the middle
of a std::vector, you're not using the right data structure. In fact,
std::vector is almost
Brian Hulley wrote:
in my particular case (which was a text buffer
for an edit control implemented as a std::vector of lines where each line
contains some book-keeping info plus a std::vector of character info)
[...]
I'm keen to learn what the Haskell way is rather than just porting my old
Neil Rutland wrote:
ttyyppee LLiinnee ==
[[((((SSttrriinngg,,SSttrriinngg)),,((SSttrriinngg,,IInntt)),,((SSttrriinngg,,IInntt)),,((SSttrriinngg,,BBooooll)),,
Shannon -jj Behrens wrote:
o How important is it that I switch from using the State monad to using
arrows?
Your problem seems to be naturally soved by the State monad, therefore
you should use that.
o How important is it that I switch from using | or $ to using
arrows?
Unimportant.
[EMAIL PROTECTED] wrote:
Today, I reviewed a function I wrote a few months ago. The function,
dropTrailNulls, takes a list of lists and drops trailing null lists. For
instance:
*Main dropTrailNulls [[1],[2,3],[],[]]
[[1],[2,3]]
dropTrailNulls = foldr dtn []
where
dtn [] [] = []
zell_ffhut wrote:
Imagine the strings are set out in a 9x9 grid type way, and i have to find
the value of a set position given 2 gird values.
getCharFromGrid (row,col) g = concat g !!(row * 9) + col
This isn't by chance evolving into the world's ugliest sudoku solver?
Are you sure, you
Shannon -jj Behrens wrote:
I find ctx | currTok | tokenType to be more readable than
tokenType $ currTok $ ctx because you're not reading the code in
reverse. That's my primary complaint with . and $.
Seconded. That's why I'd like to see the arguments to (.) swapped, but
it's too late for
Peter wrote:
So, How am I supposed to get the value of an IO Monad, such as IO
String, without returning an IO Monad?
You read correctly, this is impossible. You already got some valid
answers, and here's another variant that preserves most of the nice
guarded expressions:
recv_headers' ::
Matthias Fischmann wrote:
I want to force evaluation on an arbitrary expression.
[...]
main :: IO ()
main = do
hPutStr stdout veryLongString -- lazy
veryLongString `seq` hPutStr stdout veryLongString -- still lazy?
(StrictThingy veryLongString) `seq` hPutStr stdout
Juan Carlos Arevalo Baeza wrote:
myParser :: Parser ()
myParser =
do string Hello
optional (string , world!)
It makes no sense for myParser to generate any values, especially not
the result from the optional statement, so it is set to return ().
Don't you think this
Juan Carlos Arevalo Baeza wrote:
Udo Stenzel wrote:
Don't you think this will interfere somehow with type inference?
With type inference? No, why? I mean... specifying the type of a
function [...]
Okay, so want an implicit (return ()) only if the type of the do-block
has been explicitly
1 - 100 of 135 matches
Mail list logo
