Tomorrow, 2023-12-20, at 1930 UTC, Edsko and I will do the final #Haskell Unfolder episode of the year 2023. This time, we're going to take a bit more time and talk about "circular programs", i.e., programs that depend on their own result.
I feel like although for nerds like me putting more types in a language is a cool thing, what would be much more important as a topic of research, in practise, is reducing the syntactic overhead of type systems. I recently heard so many complaints about this, I feel like we’re not there yet; I do agree. #haskell
I think what exhibits this problem is if you’re trying to rewrite a Python script in Haskell; sure, with Dynamic and a lot of rewriting you can get somewhere near the conciseness of the Python script but not when you’re actually trying to stay safe, even things like shelling out, bracketing resources and converting between string formats take up so much space that in most cases is just not justified at all. #haskell
Time for my #introduction to the Fediverse! :masto_love:
Clash is an open source functional hardware description language built on #Haskell.
The Clash compiler allows you to use Haskell features like its strong and powerful typesystem as well as use existing Haskell code and libraries in your #FPGA and #ASIC designs! You can test your designs right inside the REPL, simulate it alongside other Haskell code or output #VHDL / #Verilog / #SystemVerilog code for synthesis.
Just ~90 minutes until the start of episode 16 of The #Haskell Unfolder. This time about some Haskell history (the Applicative Monad Proposal), a recent Mastodon thread by @MartinEscardo , and about DerivingVia!
a #haskell question. Is there an active community around here?
I can understand how typeclasses are implemented for typeclass functions that have the implementation type as first argument (such as (>>=) in the Monad typeclass).
But for signatures like return (a -> m a) is there some special magic happening?
I currently assume its compile time type inference from return being used in a context of (>>=), as >>= expects a function (a -> m b)
Anyone want to guess how many errors this code generates:
{-# LANGUAGE DerivingVia #-}
module T where
newtype OrdList1 a = OrdList1 [a]
deriving (Functor, Foldable, Traversable) via []
newtype OrdList2 a = OrdList2 [a]
deriving (Functor, Foldable, Traversable) via Maybe
Any cool open source #haskell projects? I would like to start taking a look about what a real project looks like. I know about pandoc (which I will check out), but is there something maybe related to databases or data streaming of sorts?
The glorious Glasgow Haskell Compiler is preparing for the next GHCxxxx edition. These are bundles of extensions that are considered popular, stable and useful and should be offered to any Haskeller out there. There was already one such edition, GHC2021, replacing the original Haskell standards process after GHC had become basically the only widely used Haskell implementation.
If you want to be part of this proposal, this is your chance, vote now and make Haskell more convenient for yourself!
Looking forward to streaming a new episode of the #Haskell Unfolder. Tomorrow, 2023-11-22 at 1930 UTC, Edsko and I will discuss interruptible operations, a topic that was requested by our audience during the episode we did on generalBracket.
@abuseofnotation "The tooling and documentation still leaves you feeling stupid"
If that was intended as a criticism and not a compliment (!), I tend to agree. Haskell seems to engender opaque terminology (e.g. Functor rather than Mappable). I really appreciate Haskell's mathematical basis, but tools and docs should aim to be simple and clear to make them as easy to use as possible.
Finding Success (and Failure) in Haskell by Type Classes is on sale on Leanpub! Its suggested price is $35.00; get it for $12.50 with this coupon: https://leanpub.com/sh/YgRLpd4C#Haskell
Still rough and ready, but I think "the header image on the wiki page for Constructive Solid Geometry" makes a pretty good "hello-world" for a CAD framework
Today, I finally managed to release a new version of lhs2TeX for the first time since 2020. Hopefully, building with recent GHCs should now become a bit easier again. I've also restored CI to the repository. #haskell