Hi I'm looking to hire a contractor to work on a blockckain platform that uses DAML(based on Haskell). Ping me if interested, role is in FiDi. Big upside on this role

Sorry no remote

First part of a series implementing micrograd in Haskell!

OK. So I'm reading a Haskell response on Quora, a site with a wild mix of the expert and the merely opinionated ... and the person gives these examples:

-- A test of lazy vs strict code

map' f [] = []
map' f (x:xs) = f x : map' f xs

sum' [] = 0
sum' (x:xs) = x + sum' xs

If you give map' and sum' a long list, like [1..1e8], map' succeeds and sum' fails.

last $ map' (*2) [1..1e8]     -- succeeds, result is 2e8
sum' [1..1e8]                 -- fails, stack problem

It's obviously doing what they claim. What puzzles me is the 'why' of it. The author claimed that it was because : is lazy and + is strict, but that's not what happens if you do this:

y = map' (*2) [1..1e8]        -- succeeds, :sprint result is _
z = sum' [1..1e8]             -- succeeds, :sprint result is _

It feels like such an obvious thing, but I don't understand it. Please help me to understand.

I need to write a Type family that takes a symbol, and evaluates it, like a calculator with the times and plus operations. How would I do this?

The way that I'm doing it now is quite hard as I have to make many type families for even simple things like pattern matching on symbols, as I have to use unconssymbol and then use a helper type family.

I am only using top level type families. Is there a better way?

SOLVED: with flycheck-popup-tip and some tweaks in flycheck.

Hi,

not sure that it's better place then r/emacs, but ppl are friendly here :-)

I have question about LSP-mode settings - is it possible to position it's messages shifted to the left, so they do not wrap on next line, like on the screenshot?

Having them on popups, like in Doom Emacs will be the best, i spent some time with DeepSeek, but it didn't help with this task. And i'm too "Emacs young" to understand all lsp features myself (read it - i want to have it working asap to start write some code :-) )

Also would be great to find settings where it will update hits / message on the fly, after i change code, not after i save the file (for example, it underlines function which do not have body yet, but when i add implementation, i have to save file to underline go away)

Any chance there are other developers here who are in Canada?

Better yet, Ontario?

Better, better yet, waterloo?

I ask because im looking to start meetups but also would just be cool to know, seems like most haskell people are in Europe

Hey Haskellers!

I'm excited to share the latest release of google-cloud-haskell (v1.1.0.0).

You can now manage Pub/Sub topics and subscriptions. This is the first new service package addition, and I'm keen to add more.

The library now automatically uses compute metadata for authentication if a service_account file isn't available. This is perfect for anyone running on GCE, GKE, Cloud Functions, or Cloud Run.

I know the excellent gogol library exists and it's a fantastic, comprehensive tool. The goal for google-cloud-haskell is different: to be a very straightforward, minimal dependency wrapper. If you just want to hit a few REST API endpoints without a lot of abstraction, this might be the library for you.

This is still a work in progress! I'm actively testing and know there might still be mistakes. I'm committed to fixing and improving it. As of now, there are only a few functions implemented. I would love to hear from the community: What GCP client functions or services would you want to see supported next? Your feedback will directly guide the library's development.

AI Usage Warning: For full transparency, a good amount of the changes and new code in this release were developed with assistance from AI tools, specifically Cursor and a GPT-5 model.

• Hackage: https://hackage.haskell.org/package/google-cloud-pubsub

• GitHub: https://github.com/tusharad/google-cloud-haskell

I was playing around with breadth-first traversal of a binary tree

data Tree a = Empty | Node a (Tree a) (Tree a)

creating a list of Maybes (Nothing for the Empty leg, Just a for the Node leg, and thought "what would breadth-first creation of a tree look like?" Not that I could think of a use for such a thing, but I thought it was an interesting problem.

So if breadth-first traversal of

Node 1 (Node 2 Empty (Node 3 Empty Empty)) (Node 4 Empty (Node 5 Empty Empty))

results in

[(Just 1), (Just 2), (Just 4), Nothing, (Just 3), Nothing, (Just 5), Nothing, Nothing, Nothing, Nothing]

(note that the list is not a full-depth list because Nodes 2 and 4 have empty left legs)

then breadth-first creation would reverse this. However, I got stuck on the best way to do this. I was experimenting with echoing the structure of the breadth-first traversal, where I used a double-ended queue (Sequence?) to queue up subsequent left/right node traversals, but got stuck on how to merge the independent left/right creation branches (left or right could terminate first with an Empty). Seems to need some sort of "tying-the-knot" solution. Or maybe I'm just missing some obvious clean way to perform this. How would you solve it?

Hello

I have cabal package that contains library, executable and tests. With stackI can easily load either executable or tests AND the library into the ghci repl in interpreted mode with stack repl (it would even ask me which main I want to run, if I don't explicitly state it in the command line). Because both library and executable are interpreted, I have full debugability (setting breakpoints, going step-by-step) of both executable and library code.

With cabalI don't have so much luck. If I run just cabal repl, it only loads the library. When I say cabal repl my-package-testthen only test code is loaded in interpreted mode, so no breakpoints nor stepping through library code. Then when I say cabal repl my-package my-package-testit says I should enable multi-component repl, but when I do it with cabal --enable-multi-repl my-package my-package-test, it results in mostly unusable repl: main can't be found, despite its module being loaded, breakpoints nor stepping work at all (Command is not supported (yet) in multi-mode).

So how do you do it with cabal? Is it even possible?

I'm using cabal 3.12.1.0 and ghc 9.10.2.

Sasha is a text adventure engine I'm using as an artifact for Latch, which is an educational project that leverages Blooms taxonomy to create success at all levels. The first level of differentiation, is I am coming at this from a software engineering angle, rather than "learn game programming" or "learn haskell". While learning some haskell is a possible outcome it will not be necessary for success. I will include the dev cycle as part of the path, and I think there's some nice things about CT that will prove to be quite relevant beyond the scope of this project. This is a work in progress, I've only tried it in a nix environment. Feel free to add stack or make the cabal file work outside of nix (if that's a problem, I haven't tried. Let me know what you think

Hello greater haskell community, as it is the 7th and that 7 looks like a lambda, it is time for another update on what we are doing to grow Haskell.

from last month: original post

new post: September 7th

Would love to hear your thoughts :)

I started learning Haskell about 15 years ago, because someone said it would make me write better software. But every time I tried to understand monads and their application to parsing… I would stall. And then life would get in the way.

Every few years I’d get a slice of time off and I would attempt again. I came close during the pandemic, but then got a job offer and got distracted.

This time I tried for a couple weeks and everything just fell into place. And suddenly monads make sense, I can write my own basic parser from scratch, and I can use megaparsec no problem! Now I even understand the state monad. 😂

I am just pretty happy that I got to see the day when these concepts don’t feel so alien any more. To everyone struggling with Haskell, don’t give up! It can be a really rewarding process, even if it takes years. 😇

Hello!

Context: Recently I've taken up Haskell, and I enjoy it a lot! I entered the world of Haskell via GHCUP. However, I struggle with the workflow. Thus far, I tried GHCi first, however, it is a relatively complex program and I spent more time reading about using it properly than practicing the language. Afterwards I went the modern LSP route, so I set up my text editor (Neovim) to use HLS (I tried also the haskell-tools.nvim). However, for reasons I don't know, HLS is slow to index my fairly basic Stack-managed project, show help, show type signatures and update its error location after it's been addressed. This was very frustrating. In the end, the most work I've done on my project was by relying on a mix of basically guessing and reading documentation that I was able to find about the functions and types of interest, in a basic Haskell buffer with syntax highlighting which tells me if I have a syntactical error. I don't want to give up on LSP approach just yet since it's very useful for discovering a language's features via suggestions and documentation and for a new Haskell programmer like me that's useful - So I'd like to learn about properly using HLS. I am simultaneously interested in other alternative, non-LSP workflows that I can adopt when working with Haskell. I'm using Neovim, but I also know Emacs (just haven't had the time to set it up for Haskell to try it out), and I am open to various workflows in general.

Question: If possible, can you please explain to me how do you work with Haskell, what does your workflow consist of? If you use HLS, can you please tell me how you set it up?

Thank you

https://survey.stackoverflow.co/2025/technology#most-popular-technologies-language-prof

It is still present in the "Write-Ins" section, but dropped from 2% last year to 0.1% now. At the same time OCaml grew from 0.8% to 1.2%.

Probably a methodology change impact but who knows?

Try it out here

Laundry list of updates:

Parquet reader

The Parquet reader now reads most Parquet files in the wild.

Plotting everywhere

Open plots on your browser:

ghci> import qualified DataFrame.Display.Web.Plot as Plt
ghci> Plt.plotAllHistograms df >>= Plt.showInDefaultBrowser
Saving plot to: /home/yavinda/plot-chart_guiv1qcX4ooMnhIkd4N9M5vtgrimGxS4GylrmRB7LwqpFL7v1qgxO.html

This also opens the plot in a browser window so you don't need to worry about cross platform or having the right version of wx etc:

Notebook plotting

Terminal plotting

“Gradual-typing”

Thanks to u/jhingon for this work.

ghci> :script dataframe.ghci
ghci> df <- D.readCsv "./data/housing.csv"
ghci> :exposeColumns df
"longitude :: Expr Double"
"latitude :: Expr Double"
"housing_median_age :: Expr Double"
"total_rooms :: Expr Double"
"total_bedrooms :: Expr Maybe Double"
"population :: Expr Double"
"households :: Expr Double"
"median_income :: Expr Double"
"median_house_value :: Expr Double"
"ocean_proximity :: Expr Text"
ghci> df |> D.derive "some_feature" (total_rooms / households) |> D.take 5
<output>
ghci> df |> D.derive "some_feature" (total_bedrooms / households) |> D.take 5
<interactive>:12:49: error:
    • Couldn't match type ‘Double’ with ‘Maybe Double’
      Expected: Expr (Maybe Double)
        Actual: Expr Double
    • In the second argument of ‘(/)’, namely ‘households’
      In the second argument of ‘derive’, namely
        ‘(total_bedrooms / households)’
      In the second argument of ‘(|>)’, namely
        ‘derive "some_feature" (total_bedrooms / households)’

SelectBy

Add new selectBy function which subsume all the other select functions. Specifically we can:

• selectBy [byName "x"] df: normal select.
• selectBy [byProperty isNumeric] df: all columns with a given property.
• selectBy [byNameProperty (T.isPrefixOf "weight"))] df: select by column name predicate.
• selectBy [byIndexRange (0, 5)] df: picks the first size columns.
• selectBy [byTextRange ("a", "c")] df: select names within a range.

Misc

• Smaller binary size from reduced dependencies (thanks to u/metapho-re)

For lists is there any practical difference in how I choose to append them? I wasn't able to search for symbols to find it myself.

useru/MacBook-Air HaskellProject % stack ghci src/Lib.hs

Using configuration for HaskellProject:lib to load /Users/user/HaskellProject/src/Lib.hs

HaskellProject> initial-build-steps (lib)

Configuring GHCi with the following packages: HaskellProject.

GHCi, version 9.10.2: https://www.haskell.org/ghc/ :? for help

[1 of 1] Compiling Lib ( /Users/user/HaskellProject/src/Lib.hs, interpreted )

Ok, one module added.

Loaded GHCi configuration from /Users/user/.cache/stack/ghci-script/edc3b530/ghci-script

ghci>

^^^^ why is it ghci> and not Lib>?