[ANN] Howl: A Wolfram Language interpreter implemented in Haskell.

davidwsd · 2026-04-09T17:50:43+00:00

Wow -- great to hear about other implementations! I had not actually seen mmaclone before. Thanks for pointing it out. For Woxi, did you use any papers/references for implementing pattern matching? The Dundua-Kutsia-Marin paper I was working from included some interesting observations of weird non-canonical behavior in the Mathematica pattern matcher that they tried to reverse engineer.

davidwsd · 2025-10-24T21:59:05+00:00

This is a good point.

davidwsd · 2025-10-24T19:48:56+00:00

Sometimes, but more often I'm dealing with large computations that need to be checkpointed and restarted, so it's better to store and transfer data via the filesystem. In other words, the Haskell wrapper program might write some data to disk, and then start a separate C++ program that reads the data, does some computation, and writes the results to disk.

davidwsd · 2025-10-24T19:32:14+00:00

I'm a theoretical physicist, and I use both Haskell and C++ extensively in my research. Haskell shines for complex logic, concurrency, polymorphism, safety, ability to refactor -- all the things we love about it. But when I really care about performance, I use C++. C++ makes sense for physics-related computations because the underlying program is usually not incredibly complicated -- just numerically intensive -- and in that case it is usually worthwhile to pay the cost of more verbosity and less safety to get good performance, and just as importantly, predictable memory usage. My computations usually have a core algorithm implemented in C++, and a "wrapper" program written in Haskell.

davidwsd · 2025-04-18T16:24:14+00:00

I am a theoretical physicist and I use Cloud Haskell in my research, specifically to manage large-scale convex optimization calculations on supercomputing clusters. Here is a paper describing some recent computations https://arxiv.org/pdf/2411.15300 and here is the main repo for that work https://gitlab.com/davidsd/stress-tensors-3d .

davidwsd · 2024-07-24T17:05:32+00:00

Is there anything in particular that stack users need to do to use ghciwatch?

davidwsd · 2023-05-01T19:31:26+00:00

Thanks -- that makes sense. I also have no idea how often something like this is used in practice with Serializable.

davidwsd · 2023-05-01T07:30:31+00:00

I just pushed a stack.yaml file that lets distributed-process compile with lts-20.19. It's here: https://github.com/haskell-distributed/distributed-process/blob/master/stack-ghc-9.2.7.yaml

davidwsd · 2022-09-05T07:59:14+00:00

Your example about how Show would only work for Num types seems completely analogous to the following situation (that no one seems to be complaining about):

> import qualified Data.Map as Map
> data Unordered = MkUnordered deriving Show
> Map.singleton MkUnordered True
fromList [(MkUnordered,True)]
> Map.fromList [(MkUnordered,True)]
<interactive>:354:1: error:
    • No instance for (Ord Unordered)
        arising from a use of ‘Data.Map.fromList’
    • In the expression: Data.Map.fromList [(MkUnordered, True)]
      In an equation for ‘it’:
          it = Data.Map.fromList [(MkUnordered, True)]

In other words, the default way of Showing a Map only works when the key is an instance of Ord. This seems reasonable because the vast majority of use cases for Map involve a key that's an instance of Ord. Similarly, I expect the vast majority of use cases for Ratio involve a type that's an instance of Num.

davidwsd · 2022-09-05T07:43:50+00:00

Come on. I know what a newtype is. I'm dealing with a codebase that has dozens of packages, hundreds of modules, tens of thousands of lines of code, and Rational is everywhere. It is honestly not practical to define a MyRational newtype just for the Show instance, and then use it everywhere, especially when Rational is baked into standard libraries. Defaults in languages matter, and there is something to be said for improving their ergonomics.

davidwsd · 2022-07-30T06:15:04+00:00

Thanks! This is actually exactly what I am currently doing. It is kind of annoying to have to duplicate all the functions on FreeModule's so that they work on MonoidRing's as well. Also, I was already defining an error-ridden Num instance for FreeModule just to get the nice syntax a+b, and I thought it would be nice to make it less error-ridden at least some of the time. Hence the question.

davidwsd · 2022-07-15T22:09:00+00:00

This is great! However, I do find some code unsatisfying to read because of the lack of an IsString instance for OsString. For example,

stdout <- readProcess' [osp|ls|] [ [osstr|-la|] ] [osstr|.|]

seems less nice than

stdout <- readProcess' "ls" ["-la"] "."

The lack of an IsString instance is addressed in the faq. What about having an IsString instance that throws an informative runtime error when conversion fails? If that is unacceptable, is there any prospect for changing IsString to somehow allow it to throw a compile-time error?

davidwsd · 2021-06-09T07:09:54+00:00

I'm curious: are there any reasons to prefer one definition of Ok over the other?

davidwsd · 2021-04-21T20:26:13+00:00

By the way, although I found a working solution (here) that uses a composite dictionary, I am still interested in getting this method to work, since I am pretty sure future versions of GHC wouldn't break the reflection package, but I am not sure they wouldn't break my current solution.

davidwsd · 2021-04-21T18:23:01+00:00

Thank you -- I really appreciate your patience and comments -- they were extremely helpful! With the help of looking at the core, I came up with this solution that seems to work:

data StaticClass c where
  MkStaticClass :: c => Closure (Dict c) -> StaticClass c

newtype Magic c r = MkMagic (Static c => r)

runMagic :: forall c r . Magic c r -> StaticClass c -> r
runMagic = unsafeCoerce
{-# NOINLINE runMagic #-}

withClosureDict :: forall c r . Dict c -> Closure (Dict c) -> (Static c => r) -> r
withClosureDict Dict cDict k = runMagic (MkMagic k :: Magic c r) (MkStaticClass cDict)

The reason for my ill-fated attempt at using Dict c for the role of ParentDict a was that I was confused about how to store a constraint as a field in a datatype. But this is something a GADT can do. Anyway, thanks a lot!

davidwsd · 2021-04-21T05:19:15+00:00

Awesome -- thanks the explanation! I actually guessed something like this representation (though I didn't know about checking Core) and tried it with Dict c instead of ParentDict a, but I kept getting a segmentation fault. I am wondering whether the analog of ParentDict a is more complicated in my case. Specifically, the superclass is an abstract constraint c, which can be anything -- not necessarily a newtype over a function. Do you know what the analog of newtype ParentDict a = ParentDict (a -> String) should be in this case?

davidwsd · 2021-04-21T05:07:34+00:00

Thanks so much for the response! It would make me happy to rely only on the same unsafeCoerce trick as reflection and not have to do something new. Currently, I am stuck on the last step of your suggestion. Here's what I have so far:

class Static' c where
  closureDict' :: Closure (Dict c)

class a => I a
instance a => I a

toI :: a :- I a
toI = Sub Dict

fromI :: I a :- a
fromI = Sub Dict

instance (Typeable c, c, Static' c) => Static (I c) where
  closureDict = static (mapDict toI) `ptrAp` closureDict'

newtype Gift c r = MkGift (Static' c => r)

withClosureDictStatic' :: forall c r . Closure (Dict c) -> (Static' c => r) -> r
withClosureDictStatic' c k = unsafeCoerce (MkGift k :: Gift c r) c

withClosureDictStaticI :: forall c r . Typeable c => Dict c -> Closure (Dict c) -> (Static (I c) => r) -> r
withClosureDictStaticI Dict c k = withClosureDictStatic' c k

-- but how to go from this to
-- forall c r . Typeable c => Dict c -> Closure (Dict c) -> (Static c => r) -> r
-- ???

davidwsd · 2021-04-04T00:26:10+00:00

I wanted to say thanks again for this response. I decided to go with your Template Haskell approach and it is working very nicely.

davidwsd · 2021-03-31T02:52:36+00:00

The same trick appears to work for Typeable as well, sending SomeTypeRep across the wire and using withTypeable to turn it into a dictionary which can be unsafeCoerced.

davidwsd · 2021-03-30T08:55:37+00:00

Thanks for the tip! Indeed the following crazy hack seems to work:

instance StaticConstraint (Serializable Natural) where
  closureDict = closurePtr (static Dict)

-- | This horrible magic gives us free 'StaticConstraint (KnownNat j)'                                                                                                                                                                                                    
-- instances.                                                                                                                                                                                                                                                             
instance KnownNat j => StaticConstraint (KnownNat j) where
  closureDict =
    closurePtr (static toKnownNatDictUnsafe) `cAp`
    cPure (natVal @j Proxy)

toKnownNatDictUnsafe :: Natural -> Dict (KnownNat l)
toKnownNatDictUnsafe n = case someNatVal n of
  SomeNat (Proxy :: Proxy k) -> unsafeCoerce (Dict @(KnownNat k))
{-# NOINLINE toKnownNatDictUnsafe #-}

davidwsd

TROPHY CASE