* Vasili I. Galchin:
I am going to make an assumption except for Jane Street
Capital all/most Wall Street software is written in an imperative
language.
I expect that most of it is written in Excel, which doesn't really
qualify as an imperative language. High-frequency trading is
* Niklas Larsson:
http://www.haskell.org/haskellwiki/GHC/FAQ#Why_isn.27t_GHC_available_for_.NET_or_on_the_JVM.3F
It would make a lot of sense to give GHC a .NET or JVM back end, and
it's a question that comes up regularly. The reason that we haven't
done it here, at GHC HQ, is because it's a
I'm looking for a simple implementation of the STG machine to do some
experiments, preferably implemented in something with memory safety.
Performance is totally secondary. I'm also not interested in garbage
collection details, but I do want to look at the contents of the
various stacks.
* Thomas Schilling:
Does Bernie Pope's http://www.haskell.org/haskellwiki/Ministg work for you?
MiniSTG might do it, I will definitely look at it. The source
repository is gone, but there's still a tarball on Hackage. I had
hoped for something more interactive, though.
* Jonathan Geddes:
When I write Haskell code, I write functions (and monadic actions)
that are either a) so trivial that writing any kind of unit/property
test seems silly, or are b) composed of other trivial functions using
equally-trivial combinators.
You can write in this style in any
* Mads Lindstrøm:
I got it to work :) But there seems to be some bugs in the Haskell
server certificate handling. It seems that TLS do not transfer the ST
(state, as in California) parameter in the X509 subject field. It also
seems that the Haskell server do not send the email-address.
And
Suppose I've got some named objects which reference other objects by
name:
data NodeS = NodeS {nameS :: String, refsS :: [String]}
Through name resolution, the strings are translated to the actual
nodes they denote:
data Node = Node {name :: String, refs :: [Node]}
resolve :: [NodeS] - Map
* Miguel Mitrofanov:
Not sure if that's what you need:
data NodeF f = Node {name :: String, refs :: [f (NodeF f)]}
newtype Const a b = Const a
newtype Id a = Id a
type NodeS = NodeF (Const String)
type Node = NodeF Id
Thanks for the suggestion. Yes, the resulting syntax looks better,
* Joachim Breitner:
I get regular error message from some Debian tools that check for new
upstream versions that it cannot find http://haskell.org/hmake, and
http://haskell.org/gtk2hs seems to be gone as well since the recent move
of haskell.org. Is that temporary or will these projects have
* Ben Franksen:
The other library might provide something like IORef, and then
it's impossible to uphold static guarantees.
The way it is implemented for instance in the regions package, you can lift
IO actions into the Region monad, as there are
instance MonadCatchIO pr = MonadCatchIO
* Gregory Collins:
* Andrew Coppin:
Hypothesis: The fact that the average Haskeller thinks that this
kind of dense cryptic material is pretty garden-variety notation
possibly explains why normal people think Haskell is scary.
That's ridiculous. You're comparing apples to oranges: using
* Andrew Coppin:
On 26/10/2010 07:54 PM, Benedict Eastaugh wrote:
On 26 October 2010 19:29, Andrew Coppinandrewcop...@btinternet.com wrote:
I also don't know exactly what discrete mathematics actually covers.
Discrete mathematics is concerned with mathematical structures which
are discrete,
Are there any Haskell compilers which use a calling convention which
is friendly to return stack buffers found in many modern CPUs? Such a
calling convention uses CALL/RET pairs for function calls. Tail calls
are implemented with JMP and may require shuffling the stack,
including the return
* Andy Stewart:
Many people ask What's Manatee?
A video worth a thousand words :
here is video (select 720p HD)
http://www.youtube.com/watch?v=weS6zys3U8k
Ahem:
| This video contains content from UMG. It is not available in your
| country.
___
How am I supposed to write an exception handle for an invocation
of System.IO.SaferFileHandles.openFile?
Currently, I have got this:
case req of
Open path - do
handle -openFile (asAbsPath path) ReadMode
liftIO $ forcePut result Success
run handle
Follwing
* Henning Thielemann:
Some open/close pairs have corresponding 'with' functions, that are
implemented using Exception.bracket. You can also use them within
GHCi. I think using both manual resource deallocation and finalizers
makes everything more complicated and more unreliable.
It seems
* Donn Cave:
Quoth Florian Weimer f...@deneb.enyo.de,
wikipedia: Managed code is a differentiation coined by Microsoft to
identify computer program code that requires and will only execute
under the management of a Common Language Runtime virtual machine
(resulting in Bytecode
* Vincent Hanquez:
Native means the implementation is in haskell, and the library is
not using another implementation (in another language) to do the
work: either through FFI as a binding, or as a wrapper to an
external program.
I can see how this terminology makes sense, but it's the
* Donn Cave:
wikipedia: Managed code is a differentiation coined by Microsoft to
identify computer program code that requires and will only execute
under the management of a Common Language Runtime virtual machine
(resulting in Bytecode).
I like this term, I apply it by
At least in my experience, in order to get proper resource management
for things like file or database handles, you need both a close
operation and a finalizer registered with the garbage collector. The
former is needed so that you can create resources faster than the
garbage collector freeing
* Ben Franksen:
You might be interested in Lightweight Monadic Regions
http://okmij.org/ftp/Haskell/regions.html#light-weight
which solve the problem (IMHO) in a much cleaner way, i.e. w/o explicit
closing and also w/o using finalizers.
Is this approach composeable in the sense that
* Bryan O'Sullivan:
If you know it's text and not binary data you are working with, you should
still use Data.Text. There are a few good reasons.
1. The API is more correct. For instance, if you use Text.toUpper on a
string containing latin1 ß (eszett, sharp S), you'll get the
* Simon Marlow:
In a sense the GC *is* deterministic: it guarantees to collect all the
unreachable garbage. But I expect what you're referring to is the
fact that the garbage remains around for a non-deterministic amount of
time. To me that doesn't seem to be a problem: you could run the GC
* jean-christophe mincke:
Has there already been attempts to introduce lisp like symbols in haskell?
Do you mean something like Objective Caml's polymorphic variants?
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
* Claus Reinke:
-- erase_range :: (Sequence s) = RangeTrait s - IO (RangeTrait s)
This can't work, as you can see after desugaring:
-- erase_range :: (Sequence s,RangeTrait s~rs) = rs - IO rs
There is nowhere to get 's' from, unless you start applying type families
backwards, from results
I can't figure out why the following code doesn't compile with the
October 2n GHC 6.10 beta (-XTypeFamilies -XFlexibleContexts) when the
type declaration is not commented out.
module T where
type family RangeTrait c
class InputRange r where
remaining :: r - Bool
advance :: r - r
class
I'm trying to encode a well-known, informally-specified type system in
Haskell. What causes problems for me is that type classes force types
to be of a specific kind. The system I'm targeting however assumes that
its equivalent of type classes are kind-agnositic.
For instance, I've got
class
* Derek Elkins:
On Fri, 2008-10-03 at 12:22 +0200, Florian Weimer wrote:
I'm trying to encode a well-known, informally-specified type system in
Haskell. What causes problems for me is that type classes force types
to be of a specific kind. The system I'm targeting however assumes that
its
* Luke Palmer:
For instance, I've got
class Assignable a where
assign :: a - a - IO ()
class Swappable a where
swap :: a - a - IO ()
class CopyConstructible a where
copy :: a - IO a
class (Assignable a, CopyConstructible a) = ContainerType a
class (Swappable c, Assignable
* SevenThunders:
OK it was stupid. Apparently GHC behaves differently according to what the
name of the high level source file is. If I renamed test.hc to main.hc
everything works the same as GHCi. I probably should actually read the
manual some day.
Some operating systems have a test
I'm toying a bit with Haskell and wondering what's the best way to
implement bit fiddling. Most of my applications involve serializing
and deserializing small blobs (IP packets, for instance), and after
browsing the GHC library documentation, I'm not sure which appraoch I
should use. That's why
* robert dockins:
If you want C compatibility, you need
http://www.haskell.org/ghc/docs/latest/html/libraries/base/Data.Array.Storable.html
which is similar. You then use the withStorableArray to call out to
your C functions.
Looks exactly like what I need. I'll give it a try and come
* John Goerzen:
Anyway, comments welcome.
I intend to sync this up with the CVS sources every few days until
either 1) the fptools people adopt darcs, or 2) it becomes apparent
that it's not being useful for people.
Would you please add tags regularly, so that the _darcs/inventory file
does
* John Goerzen:
Would you please add tags regularly, so that the _darcs/inventory file
does not exceed some moderate size? It's currently at 4 MB, which
seems to be a tad bit excessive to download, just to check that there
are no new patches available.
Yes, I can do that more regularly,
34 matches
Mail list logo
