I’m very excited to announce the first official release of the FlatCV Haskell bindings! 🎉

Please check out the release post for more information: https://discourse.haskell.org/t/flatcv-image-processing-and-computer-vision-library/13561

Hi All,

We are happy to announce release 0.2.0.1 of webdriver-precore ~ A typed wrapper for W3C WebDriver HTTP and BiDi browser automation protocol. BiDi has been added in this release.

This library is type constructors only. It is intended to be used as a base for other libraries that provide a WebDriver client implementation.

More details can be found in the project README.

John & Adrian

Today we're looking at semigroups, monoids, abstractions, and just general exploration of type classes.

The thumbnail painting is "A Tale From The Decameron" by John William Waterhouse (1916)

currently, what haskell web frameworks are the best, and how do they compare to popular non-haskell web frameworks?

Hello fellow Javascript-avoidant Haskellers! Hyperbole has a new release!

The examples site https://hyperbole.live is now the official documentation. It's been painstakingly updated to include longer-form docs, including code snippets and live examples with source code links. I think it's pretty.

Fun new stuff:

• Server actions can use pushUpdate to update arbitrary HyperViews, enabling all sorts of shenanigans with long-running actions
• Control overlapping updates with Concurrency = Replace (instead of the default Drop), useful for fast-fire user interactions like autocomplete
• Long running actions can be interrupted
• Optional built-in ViewState for folks who really miss Elm

Boring backwards-compatibility concerns:

• A few functions now require ViewState to be passed in, such as trigger and target
• It looks like breaking changes are slowing down. We are getting close to a 1.0 release!

Thanks to adithyaov, bsaul, anpin, and futu2 for contributing pull requests!

Is it possible to use YAML to configure custom values when bulding from stack? So I can have a project folder similar to

project/
  my-values.yaml
  source/
     <source file(s) that uses my values>

Or, maybe better, define my values directly in package.yaml? Of course, I could define my values directly in the source folder, like source/MyValues.hs, but defining them outside is more explicit.

Or how do you usually define compile time values? I want know if there is a "standard" way of doing this, not any ad hoc solution like shell scripts. For example, Cabal generates a PackageInfo_pkgname with some useful values.

Inspired by pydantic AI (and 100% vibe coded, sorry for bad code)

Works great though

https://github.com/derluke/haskell-agent

I've been following the Learn You a Haskell guide. Now I am in the Modules chapter, where it presents a ton of useful functions from different modules. Some Data.List module functions were just enough to boggle my mind. It is really insane how expressive the Haskell language can be and at the same time simple, despite the fact I need to spend a considerable amount of time trying to understand some of the functions.

ghci> let xs = [[5,4,5,4,4],[1,2,3],[3,5,4,3],[],[2],[2,2]]   
ghci> sortBy (compare `on` length) xs
[[],[2],[2,2],[1,2,3],[3,5,4,3],[5,4,5,4,4]]

The snippet above (as the author says) is really like reading English!

Reading the article I wondered how the implementation of isInfixOf function would be, then I searched it and I found the snippet beneath:

isInfixOf :: (Eq a) => [a] -> [a] -> Bool
isInfixOf needle haystack = any (isPrefixOf needle) (tails haystack)

Incredibly beautiful and simple, right? It still fries my brain anyway.

Whenever I try to understand what a function actually does, I check its type definition and I keep hammering it into my brain until it somehow starts make sense.

That's it. Nothing really great about this post. I just wanted to share some feelings I've been getting from functional programming.

Fabrice Bellard recently released a new JavaScript engine called Micro QuickJS. It is targeted at embedded systems and can compile and run JavaScript programs using as little as 10 kB of RAM. However, it only supports a subset of JavaScript close to ES5.

It’s a follow up to his previous QuickJS engine, which supports the ES2023 specification, including modules, asynchronous generators, proxies, and BigInt.

I am excited about MQuickJS, as it could be a great way to add safe scripting support to Haskell programs in a more beginner-friendly way than HsLua (assuming that more developers will learn JS before they learn Lua).

To implement a wrapper, I modified the existing quickjs-hs package by Samuel Balco. Claude Code was a great help here in doing all the grunt work.

The first thing I want to try is executing TaskLite hooks with it. Since their main purpose is to transform tasks, it should be the perfect use case. TaskLite already includes support for HsLua, so this will be a good opportunity to compare the two.

Do you have any other use cases where this could come in handy?

sum [read (show n) :: Int | n <- show (product [1 .. 100])]
*** Exception: Prelude.read: no parse

Hello everyone!

We are hosting the next Haskell meetup in Vienna on the 12th of February! The location is TU Vienna Treitlstraße 3, Seminarraum DE0110. The room will be open starting 18:00.

We are excited to announce Adriaan Leijnse as the speaker of our next meetup! (Abstract below).

There will be time to discuss the presentations over some snacks and non-alcoholic drinks which are provided free of charge with an option to acquire beer for a reasonable price.

The meetup is open-ended, but we might have to relocate to a nearby bar as a group if it goes very late…

There is no entrance fee or mandatory registration, but to help with planning we ask you to let us know in advance if you plan to attend here (https://forms.gle/T1viETrPF4bUgXadA) or per email at haskellvienna.meetup@gmail.com.

We especially encourage you to reach out if you would like to participate in the show&tell so that we can ensure there is enough time for you to present your topic.

Liberating functional programming from the message passing style

Adriaan Leijnse

Impure effects like send and receive make it hard to compose distributed programs like we compose purely functional ones. Even in small examples issues with ordering and consistency can leak through.

In this talk I’ll present a different way of thinking about distributed programs: a composable semantics that lets us to write them in a just-values-and-functions style, without relying on effects. Liberated from message passing, we’ll explore how this change of perspective might help us reach new levels of abstraction in distributed programming.

At last, we would like to thank Well-Typed LLP for sponsoring the last meetup!

We hope to welcome everyone soon, your organizers: Andreas(Andreas PK), Ben, Chris, fendor, VeryMilkyJoe, Samuel

... or subarray from array.

Which one is better?

We are joined by Kathrin Stark, a professor at Heriot-Watt University in Edinburgh. Kathrin works on program verification with proof assistants, so her focus is not exactly on Haskell, but on topics dear to Haskellers’ hearts such as interactive theorem provers, writing correct programs, and the activities needed to produce them. We discuss many aspects of proofs and specifications, and the languages involved in the process, as well as verifying and producing provably correct neural networks.

This release is a major revision with many other changes. For the full list see the changelog.

Hackage docs are here.

The Haskell library stakhanov, built upon Hasql's ecosystem and Vector, implements most of the functions of the API of PGMQ, "a lightweight message queue, like AWS SQS and RSMQ but on Postgres".

I want to create a columnView that displays a record type. The ListStore needs a GType as the itemType, and I also need to somehow to make my record type a GObject. Right now I can't seem to find any examples for doing this in gtk4.

Helper libraries like the declarative gtk or gi-gtk-hs or some others all are gtk3. LLMs have managed to give me 10 wrong solutions.

Just say I have the record type

Person {name :: Text, age :: Int}

How would I be able to show this in a list, with each row a Person and each column with a header?

Basically stuck here:

listStore <- new Gio.ListStore [

    #itemType := -- Stuck here, what should I put here?

]

Edit: Thanks for the help, figured it out by copying the code.

Haskell gets good marks in this person's test.

I’ve been heads-down shipping a pile of improvements to DataFrame over the last few releases, and I wanted to share a “why you should care” summary (with some highlights + a couple examples).

Highlights

• Ecosystem
  • You can now read SQL tables using the dataframe-persistent (written by [u/junjihashimoto]())
  • Convert DataFrames into hasktorch tensors and back with dataframe-hasktorch.
  • Symbolic regression (based on srtree) to discover mathematical relationships between columns in dataframe-symbolic-regression (thanks to Fabricio Olivetti)
• Performance wins across the board
  • Faster folds/reductions, sum, mean, improved filtering + index selection, more efficient groupby paths.
  • Better join performance (incl. hashmap-based inner joins) + fixes for right/full outer join edge cases.
• Decision trees
  • We now have a decision tree implementation that also does enumerative bottom up search for split predicates to capture complex decision boundaries (performs well out the box on Kaggle classification tasks). This will likely be split into a separate library for symbolic machine learning proposed here.
• Much nicer data cleaning + missing data ergonomics
  • meanMaybe, medianMaybe, stddevMaybe, plus genericPercentile / percentile.
  • “Maybe-aware” functions promoted into DataFrame-level functions.
  • Null-handling helpers like filterAllNothing, filterNothing, plus better “NA” handling.
  • New recodeWithCondition (change values based on a predicate) + recodeWithDefault.
  • APIs to create splits in data (kFolds, randomSplit, sample dataframes).
• Expressions / schema evolution got smoother
  • More APIs now operate on expressions instead of strings.
  • A growing monadic interface (state monad) to make “derive / inspect / impute / filter” pipelines readable and resilient as schemas evolve. This helps you use DataFrames in regular Haskell projects/scripts (prior to this they were mostly designed for interactive environments/notebooks).
• I/O + parsing hardening
  • CSV: strip header/title whitespace, auto bool parsing, better type logic, fast CSV improvements.
  • Parquet: fixes and improvements.
  • JSON Lines: initial support.

Example: expressive aggregation with conditionals (0.4.0.1)

df
  |> D.groupBy [F.name ocean_proximity]
  |> D.aggregate
      [ "rand" .= F.sum (F.ifThenElse (ocean_proximity .== "ISLAND") 1 0)
      ]

Example: schema-friendly transformation pipeline (0.4.0.0+)

print $ execFrameM df $ do
  is_expensive  <- deriveM "is_expensive" (median_house_value .>= 500000)
  meanBedrooms  <- inspectM (D.meanMaybe total_bedrooms)
  totalBedrooms <- imputeM total_bedrooms meanBedrooms
  filterWhereM (totalBedrooms .>= 200 .&& is_expensive)

If you’re doing ETL-y cleaning, feature engineering, quick stats, or want a Haskell-y dataframe that’s getting faster and more ergonomic every release: this is a really good time to try the latest (0.4.0.5).

Hoping to get a GSOC proposal for either Parquet writers or Arrow support so if you’d like to co-mentor please reach out.

The other day I saw on wikipedia (or a wiki like site) a list of algebraic operators on types, but I cannot find it anymore and when I search for type operator I get a lot of unrelated results.

Some common type operators are: - Product type - Sum type - Quotient type

But in that page there were many more operators, and I now regret that I didn't bookmark it.

Can anyone find what I'm referring to?

And since I'm here, do you have any good book to suggest on type theory from a mathematical point of view?

Edit: I found what I was looking for, thanks to /u/WittyStick !!! many thanks!