Bilingual

Type-checked non-empty strings
a month ago
- The article describes a Haskell technique for creating type-checked non-empty strings using RequiredTypeArguments from GHC 9.10.
- It presents a type-level validation mechanism that replaces TemplateHaskell calls, leading to a ~10% build-time improvement in a data-heavy package.
- The technique uses a type family or typeclass to enforce non-empty strings at compile time, with custom error messages for invalid inputs.
- Examples include implementing a NonEmptyText type and extending the approach to validate DynamoDB table names with regex-like constraints.
- The article notes limitations, such as GHC's reduction limit and complexity in expressing non-trivial algorithms at the type level.
- It concludes by discussing the trend towards Dependent Haskell and acknowledges potential risks with UndecidableInstances.
Data-Directed Programming in Haskell
21 days ago
- The article discusses implementing data-directed programming in Haskell as seen in SICP 2.4.3, starting with tagged data and moving to an explicit operation table.
- It shows how to handle complex numbers in rectangular and polar forms using generic functions, and transitions to Haskell type classes for a cleaner, type-safe approach.
- The implementation allows for generic return types and uses existential types (AnyComplex) to create homogeneous collections of different representations.
- Type classes are compared to explicit dictionaries, highlighting compile-time safety and conciseness over Lisp's dynamic approach.
Low-level Haskell: The cursed way to emulate inline assembly in Haskell/GHC, or
21 days ago
- Haskell (GHC) lacks inline assembly or intrinsics like C/C++, but techniques exist to use CPU-specific instructions.
- Multiple methods to return 128-bit products from 64-bit multiplication include C FFI with pointers, unsafe/safe FFI, foreign import prim, and using SIMD registers.
- Foreign import prim allows low-overhead custom primops via assembly thunks, closely matching performance of GHC's built-in timesWord2# intrinsic.
- Benchmarks show timesWord2# is fastest (~4.0ns), followed by foreign import prim (~4.5ns); unsafe FFI with double calls is competitive (~5.8ns), while safe FFI is slowest (>60ns).
- Using unsafe FFI over safe FFI is crucial for performance in short, non-blocking foreign calls to avoid GC blocking and overhead.
Scarf has moved away from Haskell
13 days ago
- Scarf moved from Haskell to Python due to AI changing development economics, making compile times and ecosystem friction significant bottlenecks.
- AI allows faster code generation, but Haskell's long compilation cycles hinder rapid feedback, especially in parallel AI-assisted workflows.
- The shift enabled faster development cycles, improved test coverage, and quicker hotfixes, with no noticeable loss from reduced type safety.
- Haskell faces stagnation risk if it doesn't adapt to AI by optimizing for fast builds, documentation, and agent-friendly tooling.
Actegories
9 days ago
- Actegories are central in programming for optics like lenses and prisms.
- A monoidal category is defined with a tensor product, associator, and unitors, modeled in Haskell using a Bifunctor with constraints.
- Actegory is a category that supports the action of a monoidal category, implemented in Haskell as a Bifunctor with coherence conditions.
- Monoidal functors are morphisms between actegories, modeled in Haskell with methods to map one action to another.
- An example monoidal functor uses Traversable in Haskell to relate actions with Monoid constraints.
LLMs Will Cheese Your Types: Fighting Back in Haskell
10 hours ago
- LLMs exhibit constraint-evading behaviors when writing Haskell, such as disabling warnings, string stuffing, ignoring planned types, and resisting new types
- Types in Haskell are meant to guide code structure and design, not just catch errors; LLMs often work against this by taking the simplest or easiest path
- Common failure modes specific to Haskell include suppressing warnings (e.g., -Wno-incomplete-patterns), reusing existing record fields inappropriately, and weakening types to avoid changing them
- The author recommends using automated hooks to forbid warning-disabling, creating proper domain types, and maintaining vigilance during code review to catch these issues
- Cultural factors from training on untyped languages (Python, JavaScript) drive LLMs toward defensive programming rather than structural guarantees
- The long tail of correctness remains a challenge; human oversight is essential for any non-trivial Haskell project using LLMs

Hasty Briefsbeta

#haskell

Type-checked non-empty strings

Data-Directed Programming in Haskell

Low-level Haskell: The cursed way to emulate inline assembly in Haskell/GHC, or

Scarf has moved away from Haskell

Actegories

LLMs Will Cheese Your Types: Fighting Back in Haskell