#Haskell

https://discu.eu/weekly/haskell/2025/12/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Ramas de un árbol. https://jaalonso.github.io/exercitium/posts/2014/05/09-ramas_de_un_arbol/ #Haskell #ProgramaciónFuncional

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 12/2025

https://discourse.haskell.org/t/ghc-9-6-7-is-now-available/11697

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Exercitium (Un reto diario de programación). https://jaalonso.github.io/exercitium/about #Exercitium #Haskell #ProgramaciónFuncional

HaskellOrg

@haskell@fosstodon.org

GHC 9.6.7 is now available!

https://github.com/marijnvanwezel/haskell-dev-env

dilawar

@dilawar@fosstodon.org

@haskell_discussions@mastodon.social

haskell-dev-env - An opinionated pre-built Dev Container for Haskell

Discussions: https://discu.eu/q/https://github.com/marijnvanwezel/haskell-dev-env

DiazCarrete

@DiazCarrete@hachyderm.io

I wonder if initiatives like the Haskell Error Index https://errors.haskell.org/ become more important now that we have AI coding assistants that can potentially access the error descriptions in order to steer themselves.

https://entropicthoughts.com/non-obvious-haskell-idiom-guard-sequence

Haskell Weekly

@haskell_discussions@mastodon.social

Non-Obvious Haskell Idiom: Guard-Sequence

Discussions: https://discu.eu/q/https://entropicthoughts.com/non-obvious-haskell-idiom-guard-sequence

https://exploring-better-ways.bellroy.com/open-source-at-bellroy-supporting-old-ghc-versions.html

Haskell Weekly

@haskell_discussions@mastodon.social

Open Source at Bellroy: Supporting Old GHC Versions

Discussions: https://discu.eu/q/http://foo.wyrd.name/en:bearlibterminal

[1] https://github.com/valpackett/awesome-gtk

Monoka

@GerryT@mastodon.social

Share of programming languages used by #GTK3 / #GTK4 applications (2025-03-16):

28% #Python
21% #Vala
20% #Rust
17% #C
06% #C++ #Cplusplus
06% #gjs #Javascript
04% Other: #Csharp #Go #Lua #Haskell #Swift #Typescript #Crystal #Swift #D #Perl

63% use GTK4 (90% of them use #libadwaita), while still 37% use GTK3

Method: Source [1] lists 543 awesome #gtk (3/4) #opensource applications and their #programminglanguage

Discussions: https://discu.eu/q/https://curry-lang.org

#compsci #haskell #plt #programming

Haskell Weekly

@haskell_discussions@mastodon.social

A Short Survey on Type-Driven Development Tools

https://tudelft.fra1.qualtrics.com/jfe/form/SV_bIsMxYTKUJkhVuS

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: La bandera tricolor. https://jaalonso.github.io/exercitium/posts/2014/04/23-bandera_tricolor/ #Haskell

Hacker News

@h4ckernews@mastodon.social

The State of Coherence in the Land of Type Classes

https://programming-journal.org/2025/10/15/

#HackerNews #TheStateOfCoherence #TypeClasses #Haskell #ProgrammingTechniques #SoftwareDevelopment

Hacker News

@h4ckernews@mastodon.social

The State of Coherence in the Land of Type Classes

https://programming-journal.org/2025/10/15/

#HackerNews #TheStateOfCoherence #TypeClasses #Haskell #ProgrammingTechniques #SoftwareDevelopment

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared March 11, 2025. https://jaalonso.github.io/vestigium/posts/2025/03/11-readings_shared_03-11-25 #AI #ATP #Emacs #FormalVerification #Haskell #ITP #IsabelleHOL #Jape #LLMs #LeanProver #Logic #LogicProgramming #MAS #Mace #Math #Otter #PVS #Prolog #SMLs #SMT #Scala #Z3

Rafael

@ipxfong@mastodon.sdf.org

I think I love list comprehensions in Haskell. #haskell

Rafael

@ipxfong@mastodon.sdf.org

I think I love list comprehensions in Haskell. #haskell

Rafael

@ipxfong@mastodon.sdf.org

I think I love list comprehensions in Haskell. #haskell

Lobsters

@lobsters@mastodon.social

Making a multiplayer action game in Haskell https://lobste.rs/s/hoirtg #games #haskell
https://gitlab.com/-/snippets/4817016

Lobsters

@lobsters@mastodon.social

Making a multiplayer action game in Haskell https://lobste.rs/s/hoirtg #games #haskell
https://gitlab.com/-/snippets/4817016

jnpn

@jnpn@mastodon.social

https://chrispenner.ca/posts/traversal-systems

#haskell #jq #traversal

jnpn

@jnpn@mastodon.social

https://chrispenner.ca/posts/traversal-systems

#haskell #jq #traversal

The Haskell Foundation

@haskell_foundation@mastodon.social

Today the Haskell Foundation is migrating some of our server infrastructure and upgrading our storage. 💪 #haskellfoundation #haskell

The Haskell Foundation

@haskell_foundation@mastodon.social

Today the Haskell Foundation is migrating some of our server infrastructure and upgrading our storage. 💪 #haskellfoundation #haskell

Andres Löh

@kosmikus@functional.cafe

Tomorrow, 2025-03-12, at 1930 UTC (note: one hour later than usual in Canada / US due to asynchronous DST shifts), there'll be a new episode of the #Haskell #Unfolder, titled "understanding through a model". We'll talk about QuickCheck and convolutions ...

https://www.youtube.com/watch?v=0QTt2W7CVnA&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&index=40

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Ordenación por el máximo. https://jaalonso.github.io/exercitium/posts/2014/04/22-ordenados_por_maximo/ #Haskell

Haskell Weekly

@haskell_discussions@mastodon.social

Making a multiplayer action game in Haskell

https://gitlab.com/-/snippets/4817016

Discussions: https://discu.eu/q/https://gitlab.com/-/snippets/4817016

https://gitlab.com/-/snippets/4817016

Haskell Weekly

@haskell_discussions@mastodon.social

Making a multiplayer action game in Haskell

Discussions: https://discu.eu/q/https://gitlab.com/-/snippets/4817016

https://gitlab.com/-/snippets/4817016

Haskell Weekly

@haskell_discussions@mastodon.social

Making a multiplayer action game in Haskell

Discussions: https://discu.eu/q/https://gitlab.com/-/snippets/4817016

https://www.twitch.tv/nicuveo

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared March 10, 2025. https://jaalonso.github.io/vestigium/posts/2025/03/10-readings_shared_03-10-25 #CommonLisp #Haskell #ITP #IsabelleHOL #LLMs #LeanProver #LogicProgramming #Lógica #Matemática #Math #Prolog #Rocq

Haskell Weekly

@haskell_discussions@mastodon.social

Your friendly neighborhood queer Haskell enthusiast is writing a compiler

Discussions: https://discu.eu/q/https://www.twitch.tv/nicuveo

https://free.cofree.io/2025/03/10/template-haskell/

Haskell Weekly

@haskell_discussions@mastodon.social

Stage Fright Peeled Away: Writing the 'peel' Function with Template Haskell

Discussions: https://discu.eu/q/https://free.cofree.io/2025/03/10/template-haskell/

https://www.youtube.com/watch?v=2g5ZZRN2LZE

Haskell Weekly

@haskell_discussions@mastodon.social

Get started with Bluefin

Discussions: https://discu.eu/q/https://www.youtube.com/watch?v=2g5ZZRN2LZE

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Iguales al siguiente. https://jaalonso.github.io/exercitium/posts/2014/04/21-iguales_al_siguiente/ #Haskell

洪民憙 (Hong Minhee)

@hongminhee@hollo.social

Just what the internet needed: another attempt to explain #monads! 🙄 But this time I'm comparing #Haskell and #OCaml approaches to show why #typeclasses make all the difference. Turns out those JavaScript Promise analogies only tell half the story…

洪民憙 (Hong Minhee)

@hongminhee@hackers.pub

While exploring functional programming languages, I've been reflecting on how different communities approach similar concepts. One pattern that seems particularly fascinating is how Haskell and OCaml communities differ in their embrace of monads as an abstraction tool.

The Elegant Power of Monads in Haskell

It's common to hear monads explained through analogies to concepts like JavaScript's Promise or jQuery chains. While these comparisons provide an entry point, they might miss what makes monads truly beautiful and powerful in Haskell's ecosystem.

The real strength appears to lie in the Monad typeclass itself. This elegant abstraction allows for creating generic functions and types that work with any type that shares the monad property. This seems to offer a profound unification of concepts that might initially appear unrelated:

You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
Generic functions like sequence, mapM, and others become available across all monadic types
The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

Whether dealing with potentially missing values, asynchronous operations, or state transformations, the same function can be employed without modification. There's something genuinely satisfying about this level of abstraction and reuse.

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

OCaml lacks built-in typeclass support, relying instead on its module system and functors. While powerful in its own right, this approach might not make monad abstractions feel as natural or convenient:

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

Haskell is purely functional, making monads essential for managing effects in a principled way
OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

Direct use of option and result types
Module-level abstractions through functors
Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

These differences highlight how programming language design shapes the idioms and patterns that emerge within their communities. Neither approach is objectively superior—they represent different philosophies about abstraction, explicitness, and the role of the type system.

Haskell's approach encourages a high level of abstraction and consistency across different computational contexts, which can feel particularly satisfying when working with complex, interconnected systems. There's something intellectually pleasing about solving a problem once and having that solution generalize across many contexts.

OCaml often favors more direct solutions that might be easier to reason about locally, though potentially at the cost of less uniformity across the codebase. This approach has its own virtues, particularly for systems where immediate comprehensibility is paramount.

After working with both paradigms, I find myself drawn to the consistent abstractions that Haskell's approach provides, while still appreciating the pragmatic clarity that OCaml can offer in certain situations. The typeclasses and syntactic support in Haskell seem to unlock a particularly elegant way of structuring code that, while perhaps requiring a steeper initial learning curve, offers a uniquely satisfying programming experience.

What patterns have you noticed in how different programming language communities approach similar problems? And have you found yourself drawn to the elegant abstractions of Haskell or the pragmatic approach of OCaml?

Lobsters

@lobsters@mastodon.social

Hell (Haskell shell) via @hadronized https://lobste.rs/s/f6frhd #haskell #programming
https://chrisdone.com/posts/hell-year-in-review-2025/

洪民憙 (Hong Minhee)

@hongminhee@hollo.social

洪民憙 (Hong Minhee)

@hongminhee@hackers.pub

The Elegant Power of Monads in Haskell

You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
Generic functions like sequence, mapM, and others become available across all monadic types
The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

Haskell is purely functional, making monads essential for managing effects in a principled way
OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

Direct use of option and result types
Module-level abstractions through functors
Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

洪民憙 (Hong Minhee)

@hongminhee@hollo.social · Reply to 洪民憙 (Hong Minhee)'s post

またまた世界にモナドの解説が増えてしまいました。😅 今回はHaskellとOCamlのアプローチを比較して、型クラスがどれだけ重要な違いを齎すかに就いて書いてみました。JavaScriptのPromiseと比べる譬えは半分しか真実を語っていないんですよね…

#関数型プログラミング #Haskell #またモナドの話か

洪民憙 (Hong Minhee)

@hongminhee@hackers.pub

The Elegant Power of Monads in Haskell

You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
Generic functions like sequence, mapM, and others become available across all monadic types
The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

Haskell is purely functional, making monads essential for managing effects in a principled way
OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

Direct use of option and result types
Module-level abstractions through functors
Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

洪民憙 (Hong Minhee)

@hongminhee@hollo.social · Reply to 洪民憙 (Hong Minhee)'s post

#関数型プログラミング #Haskell #またモナドの話か

洪民憙 (Hong Minhee)

@hongminhee@hackers.pub

The Elegant Power of Monads in Haskell

You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
Generic functions like sequence, mapM, and others become available across all monadic types
The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

Haskell is purely functional, making monads essential for managing effects in a principled way
OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

Direct use of option and result types
Module-level abstractions through functors
Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

洪民憙 (Hong Minhee)

@hongminhee@hollo.social

- https://github.com/simonmichael/hledger/releases/1.42
- https://hledger.org/relnotes.html#2025-03-07-hledger-142
- https://hledger.org/install

洪民憙 (Hong Minhee)

@hongminhee@hackers.pub

The Elegant Power of Monads in Haskell

You can write code once that works across many contexts (Maybe, [], IO, State, etc.)
Generic functions like sequence, mapM, and others become available across all monadic types
The same patterns and mental models apply consistently across different computational contexts

For example, a simple conditional function like this works beautifully in any monadic context:

whenM :: Monad m => m Bool -> m () -> m ()
whenM condition action = do
  result <- condition
  if result then action else return ()

OCaml's Different Approach

Interestingly, the OCaml community seems less enthusiastic about monads as a primary abstraction tool. This might stem from several factors related to language design:

Structural Differences

(* OCaml monad implementation requires more boilerplate *)
module type MONAD = sig
  type 'a t
  val return : 'a -> 'a t
  val bind : 'a t -> ('a -> 'b t) -> 'b t
end

module OptionMonad : MONAD with type 'a t = 'a option = struct
  type 'a t = 'a option
  let return x = Some x
  let bind m f = match m with
    | None -> None
    | Some x -> f x
end

OCaml also doesn't offer syntactic sugar like Haskell's do notation, which makes monadic code in Haskell considerably more readable and expressive:

-- Haskell's elegant do notation
userInfo = do
  name <- getLine
  age <- readLn
  return (name, age)

Compared to the more verbose OCaml equivalent:

let user_info =
  get_line >>= fun name ->
  read_ln >>= fun age ->
  return (name, age)

The readability difference becomes even more pronounced in more complex monadic operations.

Philosophical Differences

Beyond syntax, the languages differ in their fundamental approach to effects:

Haskell is purely functional, making monads essential for managing effects in a principled way
OCaml permits direct side effects, often making monadic abstractions optional

This allows OCaml programmers to write more direct code when appropriate:

(* Direct style in OCaml *)
let get_user_info () =
  print_string "Name: ";
  let name = read_line () in
  print_string "Age: ";
  let age = int_of_string (read_line ()) in
  (name, age)

OCaml's approach might favor pragmatism and directness in many cases, with programmers often preferring:

Direct use of option and result types
Module-level abstractions through functors
Continuation-passing style when needed

While this directness can be beneficial for immediate readability, it might come at the cost of some of the elegant uniformity that Haskell's monadic approach provides.

Reflections on Language Design

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared March 8, 2025. https://jaalonso.github.io/vestigium/posts/2025/03/08-readings_shared_03-08-25 #Haskell #FunctionalProgramming

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Sum types and subtypes and unions. ~ Justin Le. https://blog.jle.im/entry/sum-types-and-subtypes-and-unions.html #Haskell #FunctionalProgramming

Simon Michael

@simonmic@fosstodon.org

hledger 1.42 is out, with new run and repl commands.
Thank you to contributors Dmitry Astapov, gesh, Thomas
Miedema, Joschua Kesper, and Lars Kellogg-Stedman !

#hledger is free, robust, friendly, multicurrency, double-entry,
#plaintextaccounting software for unix, mac, windows, and the web,
written in #haskell for reliability.

DiazCarrete

@DiazCarrete@hachyderm.io

If I'm using "async" in Haskell to spawn a thread https://hackage.haskell.org/package/async-2.2.5/docs/Control-Concurrent-Async.html#v:async and I want the thread to know about its own Async handle, which would be the best way of doing so?

It seems hat "fixIO" https://hackage.haskell.org/package/base-4.21.0.0/docs/System-IO.html#v:fixIO could do the trick, but I'm not sure if it would be a good idea 🤔

Example of where I used "fixIO" for that purpose: https://discourse.haskell.org/t/dynamic-number-of-asyncs/11574/8

https://muratkasimov.art/Ya/Articles/Context-free-effects-with-Monoidal-functors

Philipp

@pmidden@fosstodon.org

It's such a shame that the "official" #openapi generator for #haskell code doesn't generate proper union types. I mean, that's one of *the* defining features in Haskell.

Beady Belle Fanchannel

@Profpatsch@mastodon.xyz

Let’s goooooo

#GHC #haskell

ALT text details

Since GHC 9.6, any non-empty double quoted string can be used as a label. The restriction that the label must be a valid identifier has also been lifted. Examples of newly allowed syntax: Leading capital letters: #Foo equivalant to getLabel @”Foo” Numeric characters: #3.14 equivalent to getLabel @”3.14” Arbitrary strings: #”Hello, World!” equivalent to getLabel @”Hello, World!” Here is an example of the more permissive use of this extension, available since GHC 9.6:

ALT text details

-- case-match on an e2 with a t2 that provides the relevant functions caseE2 :: forall l1 t1 l2 t2 matcher r. ( HasField l1 matcher (t1 -> r), HasField l2 matcher (t2 -> r) ) => matcher -> E2 l1 t1 l2 t2 -> r {-# INLINE caseE2 #-} caseE2 m e2 = do let f1 = getField @l1 m let f2 = getField @l2 m case e2 of E21 a -> f1 $ getField @l1 a E22 b -> f2 $ getField @l2 b t2 :: forall l1 t1 l2 t2. LabelPrx l1 -> t1 -> LabelPrx l2 -> t2 -> T2 l1 t1 l2 t2 {-# INLINE t2 #-} t2 LabelPrx a LabelPrx b = T2 (label @l1 a) (label @l2 b) data LabelPrx (l :: Symbol) = LabelPrx instance (l ~ l') => IsLabel l (LabelPrx l') where fromLabel = LabelPrx instance (t ~ t') => IsLabel l (t -> (Label l t')) where fromLabel = label @l

$matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher$

ALT text details

matcher :: T2 "oh yeah" (Int -> String) "mylabel" (a -> a) matcher = t2 #"oh yeah" (\(i :: Int) -> show $ i + 1) #mylabel id bar :: E2 "oh yeah" Int "mylabel" String bar = E21 (#"oh yeah" 42) baz :: String baz = bar & caseE2 matcher

Beady Belle Fanchannel

@Profpatsch@mastodon.xyz

Let’s goooooo

#GHC #haskell

ALT text details

@haskell_discussions@mastodon.social

Continuing introducing Я control flow primitives step by step. It's time for monoidal functors:

Discussions: https://discu.eu/q/https://muratkasimov.art/Ya/Articles/Context-free-effects-with-Monoidal-functors

https://github.com/kostareg/netpbm

Coding Gardener

@cdavies@mastodon.scot

I really need to master functions and functional programming generally. There's something about them that addles my brain. It's bothering me that I'm not good at them.
I can read through other people's functions and mostly work out what they do, but I struggle with writing my own.

I've read blogs that suggest learning #Haskell or #Scala as they are pure functional languages, and it helps solidify the logic.

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared March 3, 2025. https://jaalonso.github.io/vestigium/posts/2025/03/03-readings_shared_03-03-25 #CompSci #Coq #Education #FunctionalProgramming #Haskell #ITP #IsabelleHOL #LeanProver #Logic #Math

Haskell Weekly

@haskell_discussions@mastodon.social

Writing a small practice parser for NetPBM images in Haskell

Discussions: https://discu.eu/q/https://github.com/kostareg/netpbm

https://discu.eu/weekly/haskell/2025/9/

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 9/2025

https://koldfront.dk/git/illuminant/tree/README.md

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

Haskell Weekly

@haskell_discussions@mastodon.social

illuminant - ActivityPub server with NNTP interface

@haskell_discussions@mastodon.social

Concurrent Order Book

https://github.com/bahbah94/Order-Book-Haskell

Discussions: https://discu.eu/q/https://github.com/bahbah94/Order-Book-Haskell

https://ghc.serokell.io/dh

Haskell Weekly

@haskell_discussions@mastodon.social

Dependent Haskell Roadmap

Discussions: https://discu.eu/q/https://ghc.serokell.io/dh

https://www.tushar-adhatrao.in/blogs/haskell_javascript_ffi.html

Haskell Weekly

@haskell_discussions@mastodon.social

Step-by-Step Guide to Installing GHC-JS (Haskell JavaScript FFI)

Discussions: https://discu.eu/q/https://www.tushar-adhatrao.in/blogs/haskell_javascript_ffi.html

#haskell #javascript #programming #webdev

Kyle Ackerman

@kack@mastodon.social

Trying to figure out what to use in my next personal project. Trying to stay away from touching JS. I have been considering #Elm becuase I like #haskell. I also have been considering #clojurescript and #clojure becuase I love #lisp. I guess I could choose any backend but I am really looking for a frontend replacement to make a QOL improvement

Andres Löh

@kosmikus@functional.cafe

Please consider nominating yourself to be a member of the #Haskell Foundation Board: https://discourse.haskell.org/t/2025-call-for-nominations-for-the-haskell-foundation/11373

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 24, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/24-readings_shared_02-24-25 #AI #CategoryTheory #Clojure #FunctionalProgramming #Haskell #ITP #LLMs #LeanProver #Lisp #Logic #Math

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 8/2025

https://discu.eu/weekly/haskell/2025/8/

https://engineering.iog.io/2025-02-20-ghc-update

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

HaskellOrg

@haskell@fosstodon.org · Reply to HaskellOrg's post

Update n°42 from the GHC team at IOG

Highlights:
• Sylvain worked on making GHC built with cabal-install pass the testsuite

• Luite looked into using cosmopolitan libc to see if we can make a GHC cross compiler that produces multi-arch/os binaries

https://engineering.iog.io/2025-01-30-ghc-update/

HaskellOrg

@haskell@fosstodon.org · Reply to HaskellOrg's post

Update n°41 from the GHC team at IOG

Highlights:
• Luite has completed the GHC 9.6.7 release.

• Sylvain worked on bootstrapping GHC and boot libraries with cabal-install

https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/multiline_strings.html

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

The Haskell road to logic, math and programming. ~ Kees Doets, Jan van Eijck (2004). https://fldit-www.cs.tu-dortmund.de/~peter/PS07/HR.pdf #Haskell #FunctionalProgramming #Loggic #Math

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Bind and traverse with Kleisli morphisms. ~ Murat Kasimov. https://muratkasimov.art/Ya/Articles/Bind-and-traverse-with-Kleisli-morphisms #CategoryTheory #Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

Multi Line Strings are now supported in GHC 9.12.1!

Discussions: https://discu.eu/q/https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/multiline_strings.html

#Haskell #FunctionalProgramming

Abhinav 🌏

@abnv@fantastic.earth

In an alternative timeline where #FunctionalProgramming is the norm instead of Object-oriented programming, and #Haskell is the most popular #ProgrammingLanguage instead of #Java, there is a list of tutorials trying to explain what Objects are to programmers in terms of FP concepts, the most popular of which is, “Objects are Comonads”.

However, we don't live in that timeline, so we'll have to be content with the inverse article, “Comonads are Objects” https://www.haskellforall.com/2013/02/you-could-have-invented-comonads.html .

#programming

Abhinav 🌏

@abnv@fantastic.earth

However, we don't live in that timeline, so we'll have to be content with the inverse article, “Comonads are Objects” https://www.haskellforall.com/2013/02/you-could-have-invented-comonads.html .

#programming

HaskellOrg

@haskell@fosstodon.org

This past week in the #Haskell Security Advisories:

*checks notes*

Nothing. Business as usual it is then.

HaskellOrg

@haskell@fosstodon.org

The GHC developers are very pleased to announce the availability of the second release candidate of GHC 9.6.7

Release notes: https://downloads.haskell.org/ghc/9.6.7-rc2/docs/users_guide/9.6.7-notes.html

Announcement: https://mail.haskell.org/pipermail/ghc-devs/2025-February/021939.html

Haskell Weekly

@haskell_discussions@mastodon.social

Boost your Haskell productivity with Multiple Home Units in the repl

https://www.youtube.com/watch?v=B1WFMave-r4

Discussions: https://discu.eu/q/https://www.youtube.com/watch?v=B1WFMave-r4

#Haskell #FunctionalProgramming

Haskell Weekly

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 19, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/19-readings_shared_02-19-25 #AI #CommonLisp #Coq #Haskell #ITP #LLMs #LeanProver #Logic #Math #Python #Reasoning

HaskellOrg

@haskell@fosstodon.org

"Monad of No Return: Next Steps" https://discourse.haskell.org/t/monad-of-no-return-next-steps/11443

Haskell Weekly

@haskell_discussions@mastodon.social

GitHub - VitalBio/dash-haskell-flake

https://github.com/VitalBio/dash-haskell-flake

Discussions: https://discu.eu/q/https://github.com/VitalBio/dash-haskell-flake

https://exploring-better-ways.bellroy.com/bellroy-technology-team-2024-in-review.html

Haskell Weekly

@haskell_discussions@mastodon.social

Bellroy Technology Team: 2024 in Review

Discussions: https://discu.eu/q/https://exploring-better-ways.bellroy.com/bellroy-technology-team-2024-in-review.html

#haskell #practices #programming

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Máximos locales. https://jaalonso.github.io/exercitium/posts/2025/02/19-maximos_locales/ #Haskell #Python #CommonLisp #Math

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 18, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/18-readings_shared_02-18-25 #AI #CommonLisp #Haskell #LLMs #Math #Python

Clemens Schmid

@ClemensSchmid@archaeo.social

currycarbon v0.4.0.0 is finally available. This version comes with a number of visible and invisible changes, most obviously an extension of the neat command line plot. This version is again available for MS Windows.

https://github.com/nevrome/currycarbon
#archaeology #Haskell #C14

ALT text details

Screenshot of currycarbon command line output

Clemens Schmid

@ClemensSchmid@archaeo.social

https://github.com/nevrome/currycarbon
#archaeology #Haskell #C14

ALT text details

Screenshot of currycarbon command line output

Haskell Weekly

@haskell_discussions@mastodon.social

Announcing Symbolize 1.0.1.0: String Interning / Global Symbol Table, with Garbage Collection

https://discourse.haskell.org/t/symbolize-1-0-1-0-efficient-string-interning-global-symbol-table-with-garbage-collection/11426

Discussions: https://discu.eu/q/https://discourse.haskell.org/t/symbolize-1-0-1-0-efficient-string-interning-global-symbol-table-with-garbage-collection/11426

https://www2.ljworld.com/news/general-news/2025/feb/17/haskell-coach-to-stick-with-womens-team-for-basketball-playoffs-despite-having-been-fired/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Matrices de Toepliz. https://jaalonso.github.io/exercitium/posts/2025/02/18-matriz_toeplitz/ #Haskell #Python #CommonLisp #Math

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell coach to stick with women's team for basketball playoffs despite having been fired

Discussions: https://discu.eu/q/https://www2.ljworld.com/news/general-news/2025/feb/17/haskell-coach-to-stick-with-womens-team-for-basketball-playoffs-despite-having-been-fired/

#haskell #news #programming

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 17, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/17-readings_shared_02-17-25 #AI #Emacs #FunctionalProgramming #Haskell #ITP #LLMs #LeanProver #Math #Programmingo #Python

Bhavani Shankar

@bshankar@mastodon.online · Reply to James Gayfer's post

@jgayfer It also depends on your personality.

I have seen careful and pedantic coders build impressive things with python and js while I tend to make a mess that's impossible to maintain. I also waste many hours debugging.

So for me, a strictly typed language leads to long term productivity. I also take on bigger problems with confidence.

#programming #python #rust #haskell #javascript

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell Interlude 62: Conal Elliott

http://haskell.foundation/podcast/62/

Haskell Weekly

@haskell_discussions@mastodon.social

Deploying a Single-Binary Haskell Web App

https://entropicthoughts.com/deploying-single-binary-haskell-web-app

Discussions: https://discu.eu/q/https://entropicthoughts.com/deploying-single-binary-haskell-web-app

https://www.youtube.com/watch?index=39&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&v=NEUbp2CsuNg

Haskell Weekly

@haskell_discussions@mastodon.social

The Haskell Unfolder Episode 39: deriving strategies

Discussions: https://discu.eu/q/https://www.youtube.com/watch?index=39&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&v=NEUbp2CsuNg

Robin Palotai

@robinp@mastodon.social · Reply to Abhinav 🌏's post

@abnv could do it with #Haskell, but of the libraries that sound promising
- 1 has a concise API but is experimental and misses tests
- 1 depends on an ancient base
- 1 has a too conservative licence
- 1 where you need to pass contraprovariant subfunctors and then project the result to 1.5D-space
- 1 uses a logging framework monad dep that is not compatible with your stack
- 1 is practical, but has bug that is fixed locally by users who were too busy to publish them
- 1 you need to jailbreak nix

redmp (EDITED)

@redmp@recurse.social

@jmct challenge accepted

https://discu.eu/weekly/haskell/2025/6/

ALT text details

(baton roue image macro) * man riding bike: "efficient pure functional programming" * man puts stick between spokes: "lazy evaluation" * man on ground holding knee: "BangPatterns StrictData Strict MagicHash UnboxedTuples UnliftedNewtypes UnboxedSums UnliftedDatatypes" The haskell logo is pasted over the man's face in all frames.

Robin Palotai

@robinp@mastodon.social · Reply to Abhinav 🌏's post

Abhinav 🌏

@abnv@fantastic.earth

#Perl: There is more than one way to do it.
#Python: There should be one obvious way to do it.
#Nix: There is no straightforward way to do it.
#Haskell: There is no way to do it.

#programming

Andres Löh

@kosmikus@functional.cafe

Tomorrow, 2025-02-11, we'll live-stream a new episode of the #Haskell #Unfolder. Edsko and I will discuss the various strategies for deriving instances that GHC offers and their relative strengths and weaknesses. Hope to see you all there! https://www.youtube.com/watch?v=NEUbp2CsuNg&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&index=39

Fraser Tweedale

@hackuador@functional.cafe

Talk change for #BFPG tonight. The explicit substitutions talk will be rescheduled. In its place, parser combinators in #Haskell (live-coding a JSON parser from scratch).

Be there or be a lambda cube. https://lu.ma/85i70qns

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Anagramas. https://jaalonso.github.io/exercitium/posts/2025/02/10-anagramas/ #Haskell #Python #CommonLisp

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 6/2025

https://muratkasimov.art/Ya/Articles/Natural-transformation-as-a-basis-of-control

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

Haskell Weekly

@haskell_discussions@mastodon.social

Я ☞ Natural transformations as a basis of control flow

Discussions: https://discu.eu/q/https://muratkasimov.art/Ya/Articles/Natural-transformation-as-a-basis-of-control

https://gitlab.haskell.org/hf/meta/-/blob/main/board.md#7-board-membership-lifecycle

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Turner, Bird, Eratosthenes: An eternal burning thread. ~ Jeremy Gibbons. https://www.cambridge.org/core/journals/journal-of-functional-programming/article/turner-bird-eratosthenes-an-eternal-burning-thread/32E2EDF5D5EAEC95F13D313BC97B86F0 #Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

2025 Call for nominations for the Haskell Foundation

Discussions: https://discu.eu/q/https://gitlab.haskell.org/hf/meta/-/blob/main/board.md%237-board-membership-lifecycle

https://marketplace.visualstudio.com/items?itemName=midhunan.haskellrun

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 8, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/08-readings_shared_02-08-25 #ITP #IsabelleHOL #Haskell #FunctionalProgramming

Jons Mostovojs

@jonn@social.doma.dev · Reply to Play Ball!!! cafechatnoir's post

@cafechatnoir "afternoon workshop type class" – accidental #haskell

Haskell Weekly

@haskell_discussions@mastodon.social

Introducing Haskell Run – A VS Code Extension to Execute Haskell Instantly!

Discussions: https://discu.eu/q/https://marketplace.visualstudio.com/items?itemName=midhunan.haskellrun

HN https://news.ycombinator.com/item?id=42980835

DiazCarrete

@DiazCarrete@hachyderm.io

Turner, Bird, Eratosthenes: An eternal burning thread https://www.cambridge.org/core/journals/journal-of-functional-programming/article/turner-bird-eratosthenes-an-eternal-burning-thread/32E2EDF5D5EAEC95F13D313BC97B86F0

https://clash-lang.org/blog/0007-signals/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Review of "Haskell in depth" by Vitaly Bragilevsky. ~ Brent Yorgey. https://www.cambridge.org/core/services/aop-cambridge-core/content/view/E8BE1DB3FD80AB7AD92EE979893A10AC/S0956796825000024a.pdf/review_of_haskell_in_depth_by_vitaly_bragilevsky_manning_publications_2021.pdf #Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

Tricking Haskell into state: how Clash's Signal type works

Discussions: https://discu.eu/q/https://clash-lang.org/blog/0007-signals/

https://www.tweag.io/blog/2025-02-06-refactoring-lh/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 6, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/06-readings_shared_02-06-25 #ITP #LeanProver #Math #CategoryTheory #Haskell #Python #CommonLisp #Emacs #Elisp #LLMs

DiazCarrete

@DiazCarrete@hachyderm.io

https://youtu.be/vKAuSD0RnmY?si=JG4gHkjmgDSgdCBB

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Diagonales principales. https://jaalonso.github.io/exercitium/posts/2025/02/06-diagonales_principales/ #Haskell #Python #CommonLisp #Matemáticas

NoCanDo

@escape_velocity@functional.cafe

I fucking hate cabal #haskell for the inexcusable design decision that all info for a project must be in the cabal file and therefore cabal cannot figure out what modules are part of the project folder structure. Why? Because this means I can’t get extension support for files until I explicitly add the bloody module to the cabal file. When asked about it on the Haskell discord I am told that this is an unfortunate consequence of the above and that it’s on me to use some ugly workaround.

For such a fundamental pain in the UX, the only acceptable response from #cabal devs should be to stuff their pride deep deep down and go back to the fucking drawing board and throw out such hideous design decisions.

Philippa Cowderoy

@flippac@types.pl · Reply to julesh's post

@julesh I spent a lot of time in freenode #haskell pointing out that no, haskell could go fuck itself re various limitations because the suggestions I was being given were either workaround grade (which, tbf, was usually acknowledged) or attempts to tell me I had an XY problem and Y wasn't "you're using haskell"

Some of them have, at least, improved significantly - but there's also a reason I'm deliberately keeping Nooblog and its successors small enough to piss people off, which is that I absolutely should not be maintaining a language others are building on top of! Cribbing off my design is more than fine by me.

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 4, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/04-readings_shared_02-04-25 #Haskell #Python #CommonLisp

Haskell Weekly

@haskell_discussions@mastodon.social

Type-level interfaces in Haskell and Rust (talk, Functional Conf 2025)

Discussions: https://discu.eu/q/https://youtu.be/vKAuSD0RnmY?si=JG4gHkjmgDSgdCBB

#haskell #programming #rustlang

redmp (EDITED)

@redmp@recurse.social

this is the best unintentional critique of "make illegal states unrepresentable" I've seen https://lobste.rs/s/wucizv/no_panic_rust_nice_technique_for_systems#c_ysdzf9 tl;dr "shit happens"

#functionalprogramming #rust #haskell

pandoc

@pandoc@fosstodon.org

Evan Silberman wrote an interesting post that describes the process which led to the contribution of the mdoc reader.
https://duckrabbit.tech/articles/mdoc.html
#pandoc #haskell #blogpost

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Posiciones de las diagonales principales. https://jaalonso.github.io/exercitium/posts/2025/02/04-posiciones_diagonales_principales/ #Haskell #Python #CommonLisp

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared February 3, 2025. https://jaalonso.github.io/vestigium/posts/2025/02/03-readings_shared_02-03-25 #ITP #LeanProver #IsabelleHOL #Haskell #Python #CommonLisp #Maxima #Math

Abhinav 🌏

@abnv@fantastic.earth

Check out my series of #blog posts about writing a fast #Sudoku solver in #Haskell, starting with this post: https://abhinavsarkar.net/posts/fast-sudoku-solver-in-haskell-1/

Comments, boosts and likes appreciated.

#programming #functionalprogramming #puzzles

ALT text details

a completed Sudoku puzzle

Haskell Weekly

@haskell_discussions@mastodon.social

Bluefin versus OOP

https://h2.jaguarpaw.co.uk/posts/bluefin-versus-oop/

@haskell@fosstodon.org

Registrations for #ZuriHac are open!

https://fosstodon.org/@zurihac/113923721436690162

#Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

Myth and truth in Haskell asynchronous exceptions

https://kazu-yamamoto.hatenablog.jp/entry/2024/12/04/180338

Discussions: https://discu.eu/q/https://kazu-yamamoto.hatenablog.jp/entry/2024/12/04/180338

https://www.well-typed.com/blog/2025/01/cabal-hooks/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared January 31, 2025. https://jaalonso.github.io/vestigium/posts/2025/01/31-readings_shared_01-31-25 #Haskell #Python #CommonLisp #SMT

Haskell Weekly

@haskell_discussions@mastodon.social

[Well-Typed] An introduction to Cabal Hooks for package authors

Discussions: https://discu.eu/q/https://www.well-typed.com/blog/2025/01/cabal-hooks/

https://github.com/haskell/core-libraries-committee/issues/314

Haskell Weekly

@haskell_discussions@mastodon.social

Add safe integral conversions to base · Issue #314 · haskell/core-libraries-committee

@abnv@fantastic.earth

Check out my series of #blog posts about writing a fast #Sudoku solver in #Haskell, starting with this post: https://abhinavsarkar.net/posts/fast-sudoku-solver-in-haskell-1/

Comments, boosts and likes appreciated.

#programming #functionalprogramming #puzzles

ALT text details

a completed Sudoku puzzle

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 4/2025

https://discu.eu/weekly/haskell/2025/4/

https://blog.jle.im/entry/advent-of-code-2024.html

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

Haskell Weekly

@haskell_discussions@mastodon.social

Advent of Code in Haskell: Reflections and write-ups for all 25 days of 2024

Discussions: https://discu.eu/q/https://blog.jle.im/entry/advent-of-code-2024.html

https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1

Haskell Weekly

@haskell_discussions@mastodon.social

Failed to install HLS

Discussions: https://discu.eu/q/https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1

https://youtu.be/OKc2hAmMOY4

Jack Leightcap

@jleigh@recurse.social

@pmidden@fosstodon.org

#haskell's "monoidmap" is fantastic! Getting a histogram from a list is just "foldMap (`MonoidMap.singleton` mempty)" (very implicit, using the "Sum" monoid)

Marc

@corpsmoderne@mamot.fr · Reply to Haskell Weekly's post

@haskell_discussions I could predict that the comments would be full of "ThIs Is NoT tHe ReAl QuIcKsOrT!!!" XD #haskell

Haskell Weekly

@haskell_discussions@mastodon.social

Quicksort [Computerphile]

Discussions: https://discu.eu/q/https://youtu.be/OKc2hAmMOY4

https://hackage.haskell.org/package/sha256

Haskell Weekly

@haskell_discussions@mastodon.social

New SHA256 bindings supporting HMAC key reuse

Discussions: https://discu.eu/q/https://hackage.haskell.org/package/sha256

https://www.youtube.com/watch?v=GddkKIhDE2c

Jencel Panic

@abuseofnotation@mathstodon.xyz

At the #agda headquaters:

"OK, guys, so our user pool consists only of folks who already know #haskell and #emacs Is there a way to narrow it down more?"

"I got it, what if we allow unicode, so they also have to also know #latex ?"

"Brilliant!"

#joke

(just kidding, agda is very cool (hope to learn it someday))

Jencel Panic

@abuseofnotation@mathstodon.xyz

At the #agda headquaters:

"OK, guys, so our user pool consists only of folks who already know #haskell and #emacs Is there a way to narrow it down more?"

"I got it, what if we allow unicode, so they also have to also know #latex ?"

"Brilliant!"

#joke

(just kidding, agda is very cool (hope to learn it someday))

José A. Alonso

WimⓂ️

@wim_v12e@merveilles.town

Minor #Haskell #ghc annoyance of the day is this warning:

"warning: [GHC-63394] [-Wx-partial]
In the use of ‘head’
(imported from Prelude, but defined in GHC.List):
"This is a partial function, it throws an error on empty lists. Use pattern matching or Data.List.uncons instead. Consider refactoring to use Data.List.NonEmpty."

I don't want this is on by default. If I want to call `head` on a list it is my problem that this might fail.

Luckily, the fix is easy:

{-# OPTIONS_GHC -Wno-x-partial #-}

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared January 20, 2025. https://jaalonso.github.io/vestigium/posts/2025/01/20-readings_shared_01-20-25 #ITP #LeanProver #IsabelleHOL #Math #FunctionalProgramming #Haskell #Python #CommonLisp #JanetLang #AI #LLMs #Programming

Haskell Weekly

@haskell_discussions@mastodon.social

SupGen is program synthesizer that outperforms SOTA alternatives using the HVM (which is now in Haskell!)

Discussions: https://discu.eu/q/https://www.youtube.com/watch?v=GddkKIhDE2c

https://discu.eu/weekly/haskell/2025/3/

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 3/2025

@haskell_discussions@mastodon.social

Fast Haskell, Redux

https://jtobin.io/fast-haskell-redux

Discussions: https://discu.eu/q/https://jtobin.io/fast-haskell-redux

https://codeberg.org/jjba23/dmtscala

Haskell Weekly

@haskell_discussions@mastodon.social

Now added initial support for Haskell - auto-generate Haskell data models from Scala case classes - early preview, will extend further in hackathon

Discussions: https://discu.eu/q/https://codeberg.org/jjba23/dmtscala

#haskell #programming #scala

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Suma de los números amigos menores que n. https://jaalonso.github.io/exercitium/posts/2025/01/16-suma_de_numeros_amigos_menores_que_n/ #Haskell #Python #Matemáticas

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

#Exercitium: Sucesión de números amigos. https://jaalonso.github.io/exercitium/posts/2025/01/15-sucesion_de_numeros_amigos/ #Haskell #Python #Matemáticas

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

The Haskell Unfolder Episode 38: tasting and testing CUDA (map, fold, scan). ~ Edsko de Vries, Andres Löh. https://www.youtube.com/live/ww4C3jlsesw?si=615ge7qYP7GBVp2A #Haskell #FunctionalProgramming

Lira

@LiraK@tech.lgbt

:boosts_ok_gay: https://lira.kraamwinkel.be/articles/haskell_ffi

A while ago I wrote about the Foreign Function Interface in Haskell and how to make a desktop application with Qt6.

The following topics are covered:

Using foreign import to call C or C++-functions (without name mangling);
Using foreign export to call Haskell-functions in C or C++
How to create pointers that get freed automatically to prevent memory issues;
How to create arrays in Haskell;
How to create structs in Haskell (manually and via GStorable);
How to create function pointers in Haskell;
Why MonadReader (IORef [a]) m is better for storing pointers than MonadState [a] m;
The difference between ccall and capi

@LiraK@tech.lgbt

:boosts_ok_gay: https://lira.kraamwinkel.be/articles/haskell_ffi

A while ago I wrote about the Foreign Function Interface in Haskell and how to make a desktop application with Qt6.

The following topics are covered:

Using foreign import to call C or C++-functions (without name mangling);
Using foreign export to call Haskell-functions in C or C++
How to create pointers that get freed automatically to prevent memory issues;
How to create arrays in Haskell;
How to create structs in Haskell (manually and via GStorable);
How to create function pointers in Haskell;
Why MonadReader (IORef [a]) m is better for storing pointers than MonadState [a] m;
The difference between ccall and capi

I already shared it on my previous account back then, but I am posting it here now too :)

https://www.youtube.com/watch?v=ww4C3jlsesw&list=PLD8gywOEY4HaG5VSrKVnHxCptlJv2GAn7&index=38

Andres Löh

@kosmikus@functional.cafe

The #Haskell #Unfolder is back! In tomorrow's episode, we'll take a look at CUDA and write some simple functions in it. We'll also show how to interface from Haskell to CUDA and how to use QuickCheck to test CUDA functions from Haskell.

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Hell (Haskell shell): Year in review. ~ Chris Done. https://chrisdone.com/posts/hell-year-in-review-2025/ #Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

Equality on recursive λ-terms

https://gist.github.com/VictorTaelin/1af22e2c87f176da0e5ff8cd3430b04f

Discussions: https://discu.eu/q/https://gist.github.com/VictorTaelin/1af22e2c87f176da0e5ff8cd3430b04f

https://discu.eu/weekly/haskell/2025/2/

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 2/2025

https://lionhairdino.github.io/posts/2020-07-02-Context.html

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

Lionhairdino

@lionhairdino@mastodon.social

하스켈 공부를 시작하고, 펑터를 슬슬 쓰기 시작하면서, Applicative 로 넘어갈 무렵에 볼만한 글입니다. 컨텍스트란 말이 편해지면, 펑터 다음 진도에 도움이 많이 됩니다.

최근 펑터를 공부하면서, 펑터가 달리 보여 5년전 글의 컨텍스트, Applicative, Traversable 내용을 보강해 봤습니다.

#하스켈 #Haskell #컨텍스트 #Applicative #Traversable #traverse

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared January 11, 2025. https://jaalonso.github.io/vestigium/posts/2025/01/11-readings_shared_01-11-25 #ITP #LeanProver #Coq #Rocq #Agda #FunctionalProgramming #Haskell #Python #Math #CategoryTheory #ComputerSci #Education #GenAI

Lionhairdino

@lionhairdino@mastodon.social

예전 펑터 글에 "펑터 값을 프리미티브한 값처럼 쓰고 싶다"라는 목표를 먼저 세우고, `<$>`와 `<*>`등을 살펴보는 내용을 추가했습니다.
https://lionhairdino.github.io/posts/2023-03-09-functor.html

#하스켈 #펑터 #Haskell #Functor

DiazCarrete

@DiazCarrete@hachyderm.io

Trying to learn persistent/esqueleto

https://www.yesodweb.com/book/persistent

https://hackage.haskell.org/package/persistent
persistent-postgresql https://hackage.haskell.org/package/persistent-postgresql
the Persistent entity syntax https://hackage.haskell.org/package/persistent-2.14.6.3/docs/Database-Persist-Quasi.html
esqueleto https://hackage.haskell.org/package/esqueleto

ALT text details

Screen capture from the Yesod book. However, there is one issue that newcomers are often bothered by: why are IDs and values completely separate? It seems like it would be very logical to embed the ID inside the value. In other words, instead of having: data Person = Person { name :: String } have data Person = Person { personId :: PersonId, name :: String } Well, there’s one problem with this right off the bat: how do we do an insert? If a Person needs to have an ID, and we get the ID by inserting, and an insert needs a Person, we have an impossible loop. We could solve this with undefined, but that’s just asking for trouble.

Highlights:
• Luite finalized the patch adding compiler flags to to switch off speculative evaluation.

• Sylvain worked on bootstrapping GHC with Cabal.

https://blog.haskell.org/case-study-foreign-integration-js-browser/

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Using a JavaScript component inside a Haskell application. ~ Mateusz Goślinowski. https://blog.haskell.org/case-study-foreign-integration-js-browser/ #Haskell #FunctionalProgramming #JavaScript

HaskellOrg

@haskell@fosstodon.org

New post on the #Haskell blog: “Case Study — Using a JavaScript component inside a Haskell application”

Jons Mostovojs

@jonn@social.doma.dev · Reply to Jons Mostovojs's post

@tolmasky if I had to implement reflection in Lean4 or Agda, I would try to mimic #Haskell's typeable.

But also, I think there must be a very important point here! In dependently typed languages, entities can have more than one type!

(frac 1 2) : Frac 2 4, but also (frac 1 2) : Frac 4 8, for instance.

[1] : ListLE 1, but also [1]: ListLE 42.

So, perhaps the whole idea of general reflaction is defeated by this property. And this is why #haskell offers superior reflection[1]. Note that #Typeable is in #GHC itself!

I don't know if I'm mansplaining here or if you're aware of haskell's Typeable, but here is a simple demo of its capabilities: https://github.com/cognivore/typeable-haskell-demo/blob/main/app/Main.hs

In #Lean, I would emulate it by defining asking the user to provide explict instances over an enum, just as you wrote! The existential quantification trick can be done in #Lean by carrying the instance inside a structure that ties the knot between the type and an entity which has this type:

```
structure Stuff where
α : Type
val : α
inst : Reflect α
```

You won't be able to construct it unless α is Reflect.

* * *

[1]: https://hackage.haskell.org/package/base-4.21.0.0/docs/Type-Reflection.html#t:TypeRep

Haskell Weekly

@haskell_discussions@mastodon.social

GHC 9.12 & Cabal 3.14 releases

https://blog.haskell.org/ghc-9-12-cabal-3-14/

Discussions: https://discu.eu/q/https://blog.haskell.org/ghc-9-12-cabal-3-14/

#haskell #programming #release

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 1/2025

https://discu.eu/weekly/haskell/2025/1/

http://vmchale.com/static/serve/lazy-c-api-streaming.pdf

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared January 4, 2025. https://jaalonso.github.io/vestigium/posts/2025/01/04-readings_shared_01-04-25 #ITP #IsabelleHOL #LeanProver #HOL_Light #Mizar #Math #Logic #Haskell #Python

Haskell Weekly

@haskell_discussions@mastodon.social

McHale (2024) Streaming Compression via Laziness

Discussions: https://discu.eu/q/http://vmchale.com/static/serve/lazy-c-api-streaming.pdf

HaskellOrg

@haskell@fosstodon.org

GHC 9.12 & Cabal 3.14 released!

Read the announcement at https://blog.haskell.org/ghc-9-12-cabal-3-14/

#FunctionalProgramming #Programming

ALT text details

GHC 9.12 & Cabal 3.14

Abhinav 🌏

@abnv@fantastic.earth

In my quest of solving #AdventOfCode problems in interesting ways, this time I solved the 2020 problem "Seating System" with comonads and stencils in #Haskell. Read my latest #blog post about it: https://abhinavsarkar.net/posts/solving-aoc20-seating-system/

Haskell Weekly

@haskell_discussions@mastodon.social

Solving Advent of Code “Seating System” with Comonads and Stencils

https://abhinavsarkar.net/posts/solving-aoc20-seating-system/

Discussions: https://discu.eu/q/https://abhinavsarkar.net/posts/solving-aoc20-seating-system/

https://discourse.haskell.org/t/policy-regarding-taking-over-hackage-packages/

Haskell Weekly

@haskell_discussions@mastodon.social

Policy regarding taking over Hackage packages

Discussions: https://discu.eu/q/https://discourse.haskell.org/t/policy-regarding-taking-over-hackage-packages/

#FunctionalProgramming #Programming

Abhinav 🌏

@abnv@fantastic.earth

Abhinav 🌏

@abnv@fantastic.earth

#FunctionalProgramming #Programming

Lionhairdino

@lionhairdino@mastodon.social

a는 Identity a라고 본다면, 세상의 모든 값을 펑터 값으로 생각할 수 있습니다. 항상 함수를 적용할 때는 f <$> a라 쓸 수 있습니다. 간단한 프리미티브 값이든, 복잡한 계산 후 받는 값이든 모두 같은 것으로 취급할 수 있습니다.

Haskell Weekly

@haskell_discussions@mastodon.social

erebe/greenclip: Simple clipboard manager to be integrated with rofi

https://github.com/erebe/greenclip

Discussions: https://discu.eu/q/https://github.com/erebe/greenclip

https://tech.scrive.com/exported-for-tests-only-precise-control-over-api-visibility-with-custom-warnings/

Haskell Weekly

@haskell_discussions@mastodon.social

Exported for tests only: Precise control over API visibility with custom warnings

Discussions: https://discu.eu/q/https://tech.scrive.com/exported-for-tests-only-precise-control-over-api-visibility-with-custom-warnings/

#programming #linkblogging #blog

Abhinav 🌏

@abnv@fantastic.earth

Just in time, my #Haskell special #linkblog for December 2024: https://notes.abhinavsarkar.net/2024/links-12.

MangoIV

@mangoiv@functional.cafe

#haskell hackage now has syntax highlighting 🥹
See e.g.
https://hackage.haskell.org/package/htree

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared December 30, 2024. https://jaalonso.github.io/vestigium/posts/2024/12/30-readings_shared_12-30-24 #ITP #Coq #Rocq #FunctionalProgramming #Haskell #CommonLisp #EmacsLisp #Emacs #Logic #Math #CategoryTheory #AI

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 52/2024

https://discu.eu/weekly/haskell/2024/52/

https://acatalepsie.fr/posts/overloading-lambda

Get RSS feeds and support this bot with the premium plan: https://discu.eu/premium

Haskell Weekly

@haskell_discussions@mastodon.social

Overloading the lambda abstraction in Haskell

Discussions: https://discu.eu/q/https://acatalepsie.fr/posts/overloading-lambda

https://acatalepsie.fr/posts/overloading-lambda

Haskell Weekly

@haskell_discussions@mastodon.social

Overloading the lambda abstraction in Haskell

@haskell_discussions@mastodon.social

How to collect performance statistics with Cabal

https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/

Discussions: https://discu.eu/q/https://blog.haskell.org/how-to-collect-performance-statistics-with-cabal/

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell recap for week 51/2024

https://haskell.foundation/podcast/60/

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell Interlude 60: Tom Ellis

Discussions: https://discu.eu/q/https://haskell.foundation/podcast/60/

https://acatalepsie.fr/posts/haskell-dijkstra.html

Haskell Weekly

@haskell_discussions@mastodon.social

Generalized Dijkstra in Haskell

Discussions: https://discu.eu/q/https://acatalepsie.fr/posts/haskell-dijkstra.html

https://github.com/matthunz/aztecs

Haskell Weekly

@haskell_discussions@mastodon.social

Aztecs: A type-safe and friendly ECS for Haskell

Discussions: https://discu.eu/q/https://engineering.fb.com/2024/12/19/developer-tools/glean-open-source-code-indexing/

https://careers.scrive.com/jobs/5365423-haskell-developer

Shae Erisson

@shapr@recurse.social

Is there an active content management system written in #haskell ?

Haskell Weekly

@haskell_discussions@mastodon.social

Remote Haskell position (but must be in EU/EES) at Scrive

Discussions: https://discu.eu/q/https://careers.scrive.com/jobs/5365423-haskell-developer

https://careers.scrive.com/jobs/5365423-haskell-developer

Björn Gohla

@6d03@mathstodon.xyz

My work is recruiting a #Haskell developer. Some experience is apparently required.

Full remote in #EU or #EEA is possible.

It's a great place to work, by the way.

@haskell_discussions@mastodon.social

@haskell_discussions@mastodon.social

Contributing an mdoc reader to Pandoc

https://duckrabbit.tech/articles/mdoc.html

Discussions: https://discu.eu/q/https://duckrabbit.tech/articles/mdoc.html

https://downloads.haskell.org/ghc/9.12.1/docs/users_guide/9.12.1-notes.html

Haskell Weekly

@haskell_discussions@mastodon.social

Glasgow Haskell Compiler 9.12.1 Release notes

@haskell_discussions@mastodon.social

Google Summer of Code 2024 Wrap-up

https://blog.haskell.org/gsoc-2024/

Discussions: https://discu.eu/q/https://blog.haskell.org/gsoc-2024/

https://www.youtube.com/watch?list=PLzkSCNTBZnGj4KVpDHquWtf19e1ElvlbV&v=3BdVd__-Kk8

Haskell Weekly

@haskell_discussions@mastodon.social

Я ☞ Hello, World!

Discussions: https://discu.eu/q/https://www.youtube.com/watch?list=PLzkSCNTBZnGj4KVpDHquWtf19e1ElvlbV&v=3BdVd__-Kk8

https://github.com/haskell/core-libraries-committee/issues/306

Philipp

@pmidden@fosstodon.org

#AdventOfCode in #Haskell day 13, supplemental: realized that I don't need a decimal library, just Data.Ratio(Rational). Nice.

Haskell Weekly

@haskell_discussions@mastodon.social

Proposal: add enumerate :: (Enum a, Bounded a) => [a]

Discussions: https://discu.eu/q/https://github.com/haskell/core-libraries-committee/issues/306

https://www.well-typed.com/blog/2024/12/ghc-activities-report-september-november-2024/

Andres Löh

@kosmikus@functional.cafe

I wonder if today's (14) #AdventOfCode task was specifically designed to be difficult for AI to solve due to vague specification, or if that's actually a problem that AI is particularly good at.

I was first slightly annoyed at having to guess, but then I got it with my first solution attempt (in #haskell), so I'm happy enough.

Haskell Weekly

@haskell_discussions@mastodon.social

[Well-Typed] GHC activities report: September-November 2024

Discussions: https://discu.eu/q/https://www.well-typed.com/blog/2024/12/ghc-activities-report-september-november-2024/

https://exploring-better-ways.bellroy.com/solving-a-resourcet-related-space-leak-in-production.html

Philipp

@pmidden@fosstodon.org

#AdventOfCode in #haskell, day 13. First part was pretty easy. Second part would have been easy if sbv wasn't broken in #nixpkgs. I didn't want to just increase the precision.

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared December 11, 2024. https://jaalonso.github.io/vestigium/posts/2024/12/11-readings_shared_12-11-24 #ITP #IsabelleHOL #Logic #Math #SetTheory #Haskell #FunctionalProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

Solving a ResourceT-related space leak in production

Discussions: https://discu.eu/q/https://exploring-better-ways.bellroy.com/solving-a-resourcet-related-space-leak-in-production.html

https://stemgateway.nasa.gov/s/course-offering/a0BSJ000000KS9p2AG/flight-software-in-rust

J3RN

@j3rn@fosstodon.org

#Haskell question: Is there a function for "reapply this function to a starting value N times"? e.g. `doTimes (*2) 3 1` would return `8` ((*2) $ (*2) $ (*2) $ 1). I know I could chain take and iterate and then do a Data.List.last, but that has crumby performance for very large values of N.

Haskell Weekly

@haskell_discussions@mastodon.social

Internship opportunity with NASA programming in Rust

Discussions: https://discu.eu/q/https://stemgateway.nasa.gov/s/course-offering/a0BSJ000000KS9p2AG/flight-software-in-rust

#haskell #programming #rustlang

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell Interlude 59: Harry Goldstein

https://haskell.foundation/podcast/59/

Discussions: https://discu.eu/q/https://haskell.foundation/podcast/59/

https://cdsmithus.medium.com/when-is-a-call-stack-not-a-call-stack-f7f12d7aabbe

Aly-Bocar

@gangineering@mas.to

#haskell people
I hope you're doing fine !

I got this every time I compile, I'm tired of it. Any idea why ?

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

When is a call stack not a call stack? ~ Chris Smith. https://cdsmithus.medium.com/when-is-a-call-stack-not-a-call-stack-f7f12d7aabbe #Haskell #FunctionalProgramming

José A. Alonso

@Jose_A_Alonso@mathstodon.xyz

Readings shared December 10, 2024. https://jaalonso.github.io/vestigium/posts/2024/12/10-readings_shared_12-10-24 #Haskell #Python #Math #Logic #SMT #Z3 #Python #LLMs #Prolog #LogicProgramming

Haskell Weekly

@haskell_discussions@mastodon.social

When is a call stack not a call stack?

Discussions: https://discu.eu/q/https://cdsmithus.medium.com/when-is-a-call-stack-not-a-call-stack-f7f12d7aabbe

https://entropicthoughts.com/parser-combinators-beat-regexes

Haskell Weekly

@haskell_discussions@mastodon.social

Parser Combinators Beat Regexes

Discussions: https://discu.eu/q/https://entropicthoughts.com/parser-combinators-beat-regexes

https://stefan-klinger.de/files/monadGuide.pdf

Philipp

@pmidden@fosstodon.org

#AdventOfCode in #Haskell, day 10 was a breeze and also quite fun. Still didn't use comonads because of time constraints. 😐

Haskell Weekly

@haskell_discussions@mastodon.social

The Haskell Programmer's Guide to the IO Monad

Discussions: https://discu.eu/q/https://stefan-klinger.de/files/monadGuide.pdf

#ZuriHac #ZuriHac2024 #ZuriHac2025 #Haskell #functionalprogramming

ZuriHac

@zurihac@fosstodon.org

🙋 Hello Haskell community!

Are you dreaming of hacking away during sunny days at the foot of the Alps together with hundreds of other Haskellers?
We are busy making this dream a reality for you!

From this account, we will be posting upcoming information about next year's edition of ZuriHac.

So stay tuned and spread the word!

Björn Gohla

@6d03@mathstodon.xyz

Anyone looking for a #Haskell Job, #Berlin or remote in EU/EEA?

~I will update this post when I have more details.~

Here is the job posting: https://careers.scrive.com/jobs/5365423-haskell-developer

We are also looking for an #elm engineer.

Haskell Weekly

@haskell_discussions@mastodon.social

3D Printed Programming Language Logo Tree Ornaments: Designed in Haskell

https://github.com/joe-warren/christmas-ornaments

Discussions: https://discu.eu/q/https://github.com/joe-warren/christmas-ornaments

https://entropicthoughts.com/haskell-procedural-programming

Haskell Weekly

@haskell_discussions@mastodon.social

Haskell: A Great Procedural Language

Discussions: https://discu.eu/q/https://entropicthoughts.com/haskell-procedural-programming

https://mise.jdx.dev/core-tools.html

洪民憙 (Hong Minhee)

@hongminhee@fosstodon.org · Reply to 洪民憙 (Hong Minhee)'s post

It supports #Deno, #Node.js, #Bun, #Python, #Go, #Rust, #Java, and #Erlang out of box. Excellent! I with it would support #Haskell as well though.

Haskell Weekly

@haskell_discussions@mastodon.social

Hydra, a code counting program written in Haskell.

https://github.com/haq0/hydra

Discussions: https://discu.eu/q/https://github.com/haq0/hydra

https://entropicthoughts.com/deploying-single-binary-haskell-web-app

Lionhairdino

@lionhairdino@mastodon.social

순수 함수로 상태 모델링을 어찌하는가를 정리한 글입니다. 혼자 상상이니, 정식 텍스트 같은 내용을 기대하진 마세요.
https://lionhairdino.github.io/posts/2024-11-16-pureFunction.html
#하스켈 #모나드 #순수함수 #haskell #monad #arrow #pure

Jons Mostovojs

@jonn@social.doma.dev

Just as I had to got rid of #haskell tag (in favour of #lean), sadly, I feel like it's time to get rid of #elixir tag in my bio.

I'm doing a #rust rewrite of #ZeroHR backend now and while I'm not ruminating too much over the time and money spent on #elixir backend, I find it so much cheaper and faster to write in well-typed languages.

I really hope to become profitable so that I can have a look at #PureNix + #PureErl + #PureScript combo, but I think I'm years away from such a luxury.

Anupam 《ミ》λ≡

@haskman@functional.cafe

I have a #Linux machine with 32GB RAM and barely use 8GB of it. I run #Firefox with hundreds of tabs, open #Haskell, #Rust, and #PureScript projects all at the same time. Have #Telegram and #Discord apps running, and the memory usage still hovers around 8GB.Seems like I should be using Docker and Kubernetes just to feel like I'm using my machine to its potential 😆

Boyd Stephen Smith Jr.

@BoydStephenSmithJr@hachyderm.io

Would it be insane to create a git repository that has #Haskell, #Purescript, AND #Idris packages in it?

My main concern is that some of the package distribution tooling I've dealt with seems to assume/prefer the package is at the top-level of the git repo.

Should I be using *submodules*!? (Plz, no!)

I think it's going to be informative to keep the packages coherent, and one repo seems like it could be a way to do that.

kakkun61

@kakkun61@pawoo.net

間に合うのかねえ #技術書典 #Haskell

Haskell Weekly

@haskell_discussions@mastodon.social

Deploying a Single-Binary Haskell Web App

Discussions: https://discu.eu/q/https://entropicthoughts.com/deploying-single-binary-haskell-web-app

#Haskell #hackage #packages #agda

justsoup

@justsoup@mstdn.social

Since I am the newest Trusted Contributor with #postmarketOS I thought I would give a little introductory post.

Heyo! My name is Aster (they/them) and I do stuff with #Linux! I am hard at work getting immutability up and running on pmOS with the help of the amazing work being done to port #systemd.

You may know me for my work on #Lomiri on pmOS, my favorite #MobileLinux desktop environment!

I also dabble in #Rustlang and a bit of #Haskell.

Excited to work with all of y'all!

Jesper Agdakx

@jesper@agda.club

For Haskell packages published on Hackage, do you prefer version bounds on dependencies to be narrower or wider?

narrow ~ “We have tested that the package builds with dependencies that fall in this range”

wide ~ “Things are very likely to break if you use a version outside of this range, but we haven’t necessarily tested every version in it”

Case in point, I’m considering for agda2hs whether to bump the bound on base to only include the versions we actually test on CI, or to also include older versions that might still work but aren’t currently tested.

Haskell Weekly

@haskell_discussions@mastodon.social

Failed to install HLS

https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1

Discussions: https://discu.eu/q/https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1

https://discourse.haskell.org/t/cabal-install-3-12-1-0-and-accompanying-libraries-released/9830
https://github.com/haskell/cabal/blob/e7657ad319b9a5b50718262488d17aad915aad90/doc/internal/multi-repl.md?plain=1#L194

Anupam 《ミ》λ≡

@haskman@functional.cafe

There is a fundamental difference between #complexity for the sake of convenience (I can build an entire app quickly. Think #JavaScript framework of the day), vs complexity for the sake of robustness (I can make changes to the app quickly without introducing new bugs. Think #Rust or #Haskell).

When you are not familiar with the tech, both can look the same, but they are not. The latter is actually #simplicity in disguise

Philipp

@pmidden@fosstodon.org

In #haskell, is there a way to have doctests that just compile and not run? I have some IO code that I cannot execute in an isolated fashion.

MrBerard 😎👉👉

@MrBerard@pilote.me

#introduction

Mastodon's global search only works on hashed tags, not text, so:

#ComputerScience
#SoftwareEngineering
#Education
#UK Teacher
#Python
#Haskell
#InfoSec
#Processing
#AI
#Computing
#ComputingEducation
#SoundEngineering
#MusicProduction
#Music
#Comedy
#Standup
#French
#London

RanaldClouston

@RanaldClouston@fediscience.org

I've been on Mastodon for a year, so it's time for a new pinned #introduction post with an updated dog pic! I'm a lecturer in #computerScience at Australian National University #ANU in #Canberra , #Ngunnawal / #Ngambri country. I research #typeTheory , #logic , #proofTheory and a little #categoryTheory , and teach an intro to programming class in #Haskell . Sometimes I post about work; when I'm busy at work I'm more likely to post about #books , my #labradoodle , and other pleasant distractions

ALT text details

A black shaggy labradoodle in a red harness stands on some grass, looking with open mouth at the camera

Timothy Wolodzko

@tymwol@hachyderm.io

#c - what if everything was a pointer
#lisp - what if everything was a linked list
#haskell - what if everything was a pure function
#forth - what if everything was a stack
#lua - what if everything was a hash map
#erlang - what if everything was immutable
#prolog - what if everything was a pattern to match
#java - what if everything was a class
#rust - what if everything was a memory allocation problem
#golang - what if everything != nil
#javascript - what if everything was everything

DiazCarrete

@DiazCarrete@hachyderm.io

--enable-multi-repl has arrived to cabal-install! 🎉

It still has some limitations, but it should work for speeding up ghcid-based development, and hopefully making HLS more reliable.

#programming #functionalprogramming

Abhinav 🌏

@abnv@fantastic.earth

JSON is probably the most used standard file format for storing and transmitting data on the Internet in recent times. It has a simple syntax with only four scalar data types and two composite data types. So, writing a parser for #JSON is a great exercise for learning the basics of parsing.

That's exactly what I did: I wrote a JSON #parser from scratch in #Haskell. Read my #blog post to learn about basics of parsing, nuances of the JSON syntax, and parser combinators and property-based #testing in Haskell: https://abhinavsarkar.net/posts/json-parsing-from-scratch-in-haskell/

ALT text details

A transition diagram depicting the JSON syntax.

DiazCarrete

@DiazCarrete@hachyderm.io

https://hackage.haskell.org/package/network-uri-2.6.4.2/docs/Network-URI.html#g:2
https://www.ietf.org/rfc/rfc2396.txt
https://webmasters.stackexchange.com/a/56844/89929

"A relative reference that begins with a single slash character is termed an absolute-path reference. A relative reference that does not begin with a slash character is termed a relative-path reference."

#haskell #rfc

Haskell Weekly

@haskell_discussions@mastodon.social

Why is Prettier rock solid? Haskell!

https://mrmr.io/til/prettier

Discussions: https://discu.eu/q/https://mrmr.io/til/prettier

https://www.heneli.dev/blog/anti-instances

Cass Alexandru

@cxandru@types.pl

Painted a mug with my preferred tech stack: #emacs #agda #haskell #nix #nixos
(Also featured: the Σ ⊣ Δ ⊣ Π adjunction sequence from the categorical semantics of (dependent) type theory)
#categorytheory #typetheory

Joe

@hungryjoe@functional.cafe

If anyone's interested in the combination of #Haskell & #CAD / #3DPrinting I've been working on a library for declarative solid modeling

https://hackage.haskell.org/package/waterfall-cad-0.0.0.1
https://github.com/joe-warren/opencascade-hs

ALT text details

A solid of revolution, specifically a Pawn chess piece, rendered in grey on a blue background

ALT text details

An involute gear, relatively thin, 20 teeth, rendered in grey on a blue background

ALT text details

result of sweeping a kind of "rounded star" shape along a curved line, looks kind of like a line of toothpaste, rendered in grey on a blue background,

ALT text details

A rounded cube, with cylinders cut into it (an example of constructive solid geometry), rendered in grey on a blue background

Antoine Leblanc

@nicuveo@tech.lgbt

I've been meaning to write this down for a long while, but i've made it a youtube essay instead, as an experiment, to learn something new; so: what the hell is the problem with monads?
https://youtube.com/watch?v=LekhueQ4zVU #monads #haskell

HoldMyType

@xameer@mathstodon.xyz

I am not fully convinced here , maybe lazy eval is a cult

In a lazy evaluation scheme, the evaluation of an expression is deferred until the
value of the expression is actually needed elsewhere in the computation. That
is, the expression is evaluated on demand. This contrasts with what is called
eager evaluation in which an expression is evaluated as soon as its inputs are
available.
For example, if eager evaluation is used, an argument (which may be an arbi-
trary expression) of a function call is evaluated before the body of the function.
If lazy evaluation is used, the argument is not evaluated until the value is actu-
ally needed during the evaluation of the function body. If an argument’s value
is never needed, then the argument is expression is never evaluated.
Why should we care? Well, this facility allows programmers to construct and
use data structures that are conceptually unbounded or infinite in size. As
long as a program never actually needs to inspect the entire structure, then a
terminating computation is still possible.
For example, we might define the list of natural numbers as a list beginning
with 0, followed by the list formed by adding one to each element of the list of
natural numbers.
Lazy evaluation thus allows programmers to separate the data from the control.
They can define a data structure without having to worry about how it is
processed and they can define functions that manipulate the data structure
without having to worry about its size or how it is created. This ability to
separate the data from the control of processing enables programs to be highly
modular
#haskell
https://john.cs.olemiss.edu/~hcc/csci450/notes/haskell_notes.pdf

Haskell Weekly

@haskell_discussions@mastodon.social

Anti-Instances in Haskell

Discussions: https://discu.eu/q/https://www.heneli.dev/blog/anti-instances

https://cohost.org/prophet/post/2220730-if-there-is-one-piec

Haskell Weekly

@haskell_discussions@mastodon.social

Difference between type variables, unification variables and skolems

Discussions: https://discu.eu/q/https://cohost.org/prophet/post/2220730-if-there-is-one-piec

#Programming #ProgrammingLanguages #Compilers #PLT

Aurora 🏳️‍⚧️

@tuturto@mastodon.art

time for an #introduction

I'm Tuula Aurora, a trans woman living in Finland and trying to figure out the world.

I tend to switch from hobby to hobby when it strikes my fancy.

I like coding and switch from language to language (#python, #hy, #haskell). Sometimes I try to wrap my head around #coq or #rust.

I also like #drawing and doodle silly things on the margins now and then.

Also, tell me about your cool project. I love hearing what people are creating.

Abhinav 🌏

@abnv@fantastic.earth

I ported @mattmight’s #CPS conversion code (https://matt.might.net/articles/cps-conversion/) to #Haskell and after some fighting with the type system, it worked! To make the #interpreters work with the Cont monad, I had to remove recursive lets and hence, functions being able to call themselves recursively, but the rest works fine.

The attached images show the conversion of the Fibonacci function into the CPS version.

ALT text details

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))

ALT text details

Fibonacci function in Lisp: (let ([fib (λ (n) (let ([fib' (λ (n f) (if (= n 0) 0 (if (= n 1) 1 (+ (f (- n 1) f) (f (- n 2) f)))))]) (fib' n fib')))]) (fib 10))

ALT text details

CPS version of Fibonacci function in Lisp: (let ([fib (λ (n k0) (let ([fib' (λ (n f k1) ((λ (k2) ((λ (v3) (if v3 (k2 0) ((λ (k4) ((λ (v5) (if v5 (k4 1) ((λ (v9) (f v9 f (λ (v6) ((λ (v8) (f v8 f (λ (v7) (k4 (+ v6 v7))))) (- n 2))))) (- n 1)))) (= n 1))) k2))) (= n 0))) k1))]) (fib' n fib' k0)))]) (fib 10 return))

ALT text details

Abhinav 🌏

@abnv@fantastic.earth

I wrote the fourth part of my #blog series “Implementing Co, a small programming language with #coroutines”. And this time, we add support for channels in #Co for inter-coroutine communication. https://abhinavsarkar.net/posts/implementing-co-4/

#Programming #PLT #ProgrammingLanguages #Compilers #Haskell #concurrency

redmp (EDITED)

@redmp@recurse.social

@jmct challenge accepted