So, i've built a project and i am new to Haskell environment coming from Ruby, Go, Python.

When i try to deploy Haskell project, it's gets stuck in pulling packages and compiling them. I suspect the problem is my development machine is way stronger than the commodity VPS i deploy on (limited cpu/memory), enough to run the binary but not enough to build on it.

in Go, i cross compile and upload a binary.

What are my possible options here?

Company is sponsoring certification/training/course. Anything related to FP that I can do?

I’m in need of a documentation writer well versed in Haskell and purescript. We’re running into issues regarding training because as you know there’s not that much material freely available for a standardized onboarded training.

The documentation written will include open source projects and our internal projects. The documentation made for open source projects will be made freely available on our public facing documentation website to help the Haskell and purescript community.

The main technologies we use are

Purescript,
Halogen,
Purescript-css

Haskell,
Servant,
Opaleye

Were also generating the cross concerning layers. So the domain layer is being autogenerated, and the purescript client to the backend is being autogenerated from servant.

Continuing my previous post on r/haskell,
about how difficult it is finding work as a haskell developer, I know finding projects on GitHub, connecting with peers working on haskell is the right approach but anyway I started doing research, I had accounts on Upwork, freelancer.com, peopleperhour and fiverr. SoI thought, what are the chances? First I went to Upwork, I could find projects on data mining, analytics, ai chatbot development, ai integration, agentic workflows but not a single one requiring haskell. Every posting has skill requirements wich I would call mainstream requirements from python, javascript and xyz family of oops languages. freelancer did not even yield a single result when I tried keywords like haskell developer, smart contracts developments using haskell, mining, analytics using haskell etc.
Same happened with peopleperhour, All empty.
Heres something interesting I found on fiverr. Ten listings of guys offering teaching and code reviewing services with Haskell.

Hmm, so whats the future holds?
I am not sure, but I am thinking about the Haskell community.

Some final words on our EmuDevz JavaScript emulator, which is finally finished, and then on to the next challenge...writing an NES emulator in Haskell!

If you want to skip the introductory remarks about the JavaScript code and get straight to the Haskell, skip to around 3:45.

Thumbnail painting: "Napoleon Crossing the Alps", by Jaques Louis-David (1801).

In the new Haskell Interlude, we talked to Fraser Tweedale. Fraser works at Red Hat, and is on the Haskell Security Response Team. We talked about security in the context of Haskell, both technical and organizational issues, and also the political issues involved. Fraser’s work is both really important and not well-known in the Haskell ecosystem, so it was high time for him to come on the show.

i work at a legal tech company and we have about 190 youtube videos. recorded CLE presentations, product walkthroughs for attorneys, internal engineering talks, some webinar recordings from conferences. the attorneys kept asking "do we have a video that explains X" and nobody had a fast way to answer because the videos are titled things like "Webinar Recording - Nov 2024."

i built a search tool for it in haskell over a weekend. mostly because i wanted a real project to work on outside of the toy stuff i've been doing while learning.

the api is defined with servant. two endpoints. one serves the static html page, the other takes a query parameter and returns search results as json. the result type is a record with the video title, date, speaker, transcript snippet, and youtube url. servant gives me the type-safe routing and the aeson instances get derived generically for the response type. the whole api definition and server are maybe 60 lines.

the database layer uses postgresql-simple. i wrote a search function that takes a connection and a query string and returns [SearchResult]. the query uses postgres full text search with tsvector on the transcript column and ts_headline for the snippet. the raw sql is in a quasiquoted string which isn't beautiful but it works and the function signature keeps everything honest. the db module is about 40 lines.

for pulling the transcripts i wrote a separate ingestion binary. it reads urls from a file, calls transcript api for each one:

npx skills add ZeroPointRepo/youtube-skills --skill youtube-full

the ingestion tool uses http-conduit for the api calls and aeson to parse the json response. each transcript gets inserted into postgres with the metadata. about 50 lines for the ingestion tool.

the part i enjoyed was defining the SearchResult type and having everything downstream just work. the aeson ToJSON instance is derived, servant uses it to serialize the response, and the postgresql-simple FromRow instance maps the query results. once the types compiled i didn't have a single runtime error related to data shape. the only bugs were in the sql query itself which is the one place haskell can't help you.

deployed it with a nix flake that builds the executable. copied it to our internal server, set up a systemd service, done. about 190 videos indexed. the legal team uses it to find CLE recordings by topic. one attorney searched for "fiduciary duty" and found 6 videos she didn't know existed. the engineering team uses it before architecture discussions to check if someone already presented on the approach.

the codebase is three modules and a Main. maybe 200 lines of haskell total. not counting the cabal file which is honestly longer than some of the modules.

I feel like it's very difficult to find any jobs where people write Haskell,

If you are one of the lucky ones who get paid to write Haskell, which domain do you use Haskell for? Is it data science, ml, academia or anything else? Did your company move from using any mainstream language to starting using Haskell? Is your company a brand new startup (e.g., database / distributed systems, Ai) where you didn’t consider Haskell initially but now feel more comfortable! What was your the initial choice?

I want to hear stories about how people ended up writing Haskell for a living (and not just as a weekend hobby).

I wrote a small article around implementing Cartesian products, starting from Haskell’s sequence.

The article goes through a naive Haskell implementation, a more idiomatic list-comprehension version, native sequence, then versions using Data.Vector.Unboxed, mutable vectors, runST, unsafeFreeze to try a different memory representation.

The second half compares those designs with C implementations, mostly to look at what changes when the memory layout and allocation model are made explicit.

The most interesting result for me was that changing representation in Haskell reduced allocations a lot without automatically improving runtime. In some cases, fusion helped a bit (no temporary indices).

I’d be happy to get feedback on the Haskell side, especially the vector/ST implementations and whether there are more idiomatic or faster ways to express this.

Here is the article link:

https://julienlargetpiet.tech/articles/the-cartesian-product-disaster-tour-haskell-c-and-25gb-of-allocations.html

If you want to share any optimizations, you can do a PR at this repo:

https://github.com/julienlargetpiet/PerfLabs

It will be mentioned in the next article update.

PS: We now managed to find (currently) best version which is this one (in C) running at 160ms for 100k iterations to 5^5 lists here:

https://github.com/julienlargetpiet/PerfLabs/blob/main/CartesianProduct/contrib2/contrib2.c

I'm updating after trying some new Haskell impl, thanks everyone for the help and the intuition on where to dig !

linear-locks provides locking primitives that are statically guaranteed not to lead to deadlocks.

It achieves this by breaking one of the Coffman conditions for deadlocks: the "circular wait" condition. linear-locks ensures locks are always acquired in a consistent order.

tl;dr: Each lock is assigned a "level", tracked at the type level. When you enter a "lock scope", you're given a key that can acquire locks of level 0 or above. When you acquire a lock of level n, the key is consumed and you're given a new key of level n+1, capable of acquiring locks of level n+1 or above. This ensures locks are always acquired in order of increasing level, preventing circular waits.

The package ports the ideas of the Surelock Rust crate to Linear Haskel. As such, it relies heavily on LinearTypes and is meant to be used with linear-base. Keys are linearly typed to ensure they cannot be reused and do not escape the "lock scope". "Guards" (which represent ownership over acquired locks) are also linearly typed to ensure they are (1) always released and (2) cannot be used after being released.

• Hackage
• GitHub

It’s a pleasure to announce hpgsql, a PostgreSQL driver written in pure Haskell (no libpq), with an API largely inspired by the great postgresql-simple library, but featuring:

• Usage of PostgreSQL’s binary protocol
• Query arguments passed via the protocol instead of being escaped into the query string
• Pipelining
• Prepared statements
• Ability to stream query results directly from the socket (not just with cursors)
• Interruption safety, except for very specific (and documented) edge cases
• Thread safety, unless specific (and documented) instructions say otherwise
• A SQL quasiquoter like the one in postgresql-query and hasql-interpolate

Here’s an example of a pipeline mixing streams, prepared and non prepared statements:

f :: Int -> IO (Stream (Of Aeson.Value) IO ())
f val = do
  (updateTbl :: IO (), aggRes :: IO (Only Int), largeResults) <-
    runPipeline conn $
      (,,)
        <$> pipelineExec_ [sql|UPDATE tbl SET val=#{val}|]
        <*> pipeline1 [sql|SELECT SUM(val) FROM tbl|]
        <*> pipelineSWith
          (rowDecoder @(Vector Int, Vector Text))
          -- We use a prepared statement for the query below
          [sqlPrep|SELECT x, y FROM tbl|]
  updateTbl
  Only total <- aggRes
  Streaming.map Aeson.toJSON <$> largeResults

Also, I am maintaining hpgsql-simple-compat, a fork of postgresql-simple that preserves its API as much as I could make it, but with internals rewritten to use hpgsql. The idea is to provide a simpler migration path from postgresql-simple; one that allows a smaller initial changeset and then the possibility of migrating queries to hpgsql one at a time. I have even migrated a CLI tool of mine, codd, as an example.

hpgsql-simple-compat is not in Hackage as I wasn’t sure duplicating the search space with modules, types, and functions already in postgresql-simple would annoy users. It’s in the “hpgsql-simple-compat” folder in the repository.

Some initial benchmarks show hpgsql can materialize rows from a query in ~38% the time postgresql-simple takes, and ~70% the time hasql takes (on my computer, Linux x64, GHC 9.10.3, compiled with -O1). Peak memory usage is trickier to analyze, and I therefore welcome people that know more to read the benchmarks page and help me better understand them. Also, please scrutinize these benchmarks as much as you can.

I want to encourage and welcome contributions, bug reports, questions, suggestions. Nothing’s off the table: what would you want or what do you need from such a library?

I really want to hear from the community, both those eager to switch and potential future users.

• Link to the repository: GitHub - mzabani/hpgsql: A pure Haskell (no libpq) postgresql driver that draws inspiration from postgresql-simple, has streaming built into its core, speaks postgresql's binary protocol, has pipelining, interruption safety, and (reasonable) thread safety. · GitHub (contains both hpgsql and hpgsql-simple-compat)
• Link to hackage: https://hackage.haskell.org/package/hpgsql

Hi, I'm learning Haskell, and I admit I'm just playing with it right now.

While I'm not a terribly experienced programmer, I do have a Bachelor's in Computer Science. My professional experience has been restricted to mostly web development in Typescript sadly.

I have not touched functional programming, but this seems unrelated to functional intricacies and more me having a primitive understanding of number types.

I'm playing with pattern matching and guards so maybe excuse the silly code, I'm just starting.
I try loading (":l haskell_test.hs") my file in GHCi and get the following compile error

"Could not deduce ‘RealFrac a’ arising from a use of ‘floor’ from the context: Num a" . I take in type Num, and floor doesn't like that general of a type, I take it?

-- testing pattern matching and guards
isXFactorOfY :: Num a => a -> a -> Bool
isXFactorOfY 0 0 = True
isXFactorOfY 0 y = False
isXFactorOfY x 0 = False
isXFactorOfY 1 1 = True
isXFactorOfY 1 y = False
isXFactorOfY x 1 = False
isXFactorOfY x y  | x > y = False
                  | abs(x / y) > floor( abs(x)/abs(y) ) = False
                  | otherwise = True

I've tried replacing Num a with Real a, RealFrac a, and some other things I've seen. But I'm just poking blindly and don't actually understand the exact issue. I'd like some help understanding it explicitly rather than stumbling upon the compile-able code.

I see the reference for floor is here: https://hackage.haskell.org/package/ClassyPrelude-0.1/docs/Prelude-Math.html#v:floor

I guess I'm confused what it want's floor to take in, I figured any number that's an Int or Float would work. But I'm not sure how to define that the way it wants.

Again sorry for the silly code. I am quite rusty and am having a rough time getting back into .... problem solving, and reading APIs and references it seems.
Thank you in advance for any help or direction you give.

The full compile error output is as follows:

ghci> :l haskell_test.hs 
[1 of 2] Compiling Main             ( haskell_test.hs, interpreted )
haskell_test.hs:3:14: error: [GHC-39999]
    • Could not deduce ‘Eq a’ arising from the literal ‘0’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Eq a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the pattern: 0
      In an equation for ‘isXFactorOfY’: isXFactorOfY 0 0 = True
  |
3 | isXFactorOfY 0 0 = True
  |              ^

haskell_test.hs:9:29: error: [GHC-39999]
    • Could not deduce ‘Ord a’ arising from a use of ‘>’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Ord a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the expression: x > y
      In a stmt of a pattern guard for
                     an equation for ‘isXFactorOfY’:
        x > y
      In an equation for ‘isXFactorOfY’:
          isXFactorOfY x y
            | x > y = False
            | abs (x / y) > floor (abs (x) / abs (y)) = False
            | otherwise = True
  |
9 | isXFactorOfY x y        | x > y = False
  |                             ^

haskell_test.hs:10:33: error: [GHC-39999]
    • Could not deduce ‘Fractional a’ arising from a use of ‘/’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (Fractional a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the first argument of ‘abs’, namely ‘(x / y)’
      In the first argument of ‘(>)’, namely ‘abs (x / y)’
      In the expression: abs (x / y) > floor (abs (x) / abs (y))
   |
10 |                         | abs(x / y) > floor( abs(x)/abs(y) ) = False
   |                                 ^

haskell_test.hs:10:40: error: [GHC-39999]
    • Could not deduce ‘RealFrac a’ arising from a use of ‘floor’
      from the context: Num a
        bound by the type signature for:
                   isXFactorOfY :: forall a. Num a => a -> a -> Bool
        at haskell_test.hs:2:1-39
      Possible fix:
        add (RealFrac a) to the context of
          the type signature for:
            isXFactorOfY :: forall a. Num a => a -> a -> Bool
    • In the second argument of ‘(>)’, namely
        ‘floor (abs (x) / abs (y))’
      In the expression: abs (x / y) > floor (abs (x) / abs (y))
      In a stmt of a pattern guard for
                     an equation for ‘isXFactorOfY’:
        abs (x / y) > floor (abs (x) / abs (y))
   |
10 |                         | abs(x / y) > floor( abs(x)/abs(y) ) = False
   |                                        ^^^^^

Failed, unloaded all modules.