haskell

Bilingual

Twenty Years of Pandoc
a month ago
- Pandoc was created by John MacFarlane in 2006 as a Haskell program for document conversion, initially supporting Markdown, reStructuredText, HTML, and LaTeX.
- The project grew over 20 years to support over 50 input formats and 76 output formats, becoming the most popular Haskell program and integrated into tools like Quarto and Jupyter.
- Pandoc's architecture uses a universal abstract syntax tree (AST) with readers and writers, enabling N×M conversions and extensibility.
- Haskell's algebraic data types, strong type system, and purity were crucial for managing the project's complexity and ensuring reliability.
- Major milestones include template system (2010), GitHub move (2010), docx/EPUB support, Lua filters, JSON filters, commonmark spec (2014), Pandoc 2.0 with PandocMonad, and Pandoc 3.0 modularization.
- Pandoc gained citation processing, syntax highlighting, and support for many markup languages through contributions from over 600 people.
- Recent additions include Typst, djot, WASM support, and various readers/writers (mdoc, POD, BBCode, etc.).
- The project received a $100,000 donation from Handshake in 2018 and continues to be actively maintained with daily bug fixes and improvements.
- MacFarlane reflects on the choice of Haskell, noting its benefits for maintainability and correctness compared to other languages.
- Future of pandoc may be challenged by LLMs, but pandoc offers advantages in efficiency, determinism, and reliability for document conversion.
Entropic Thoughts
2 months ago
- Esqueleto is a type-safe library for writing SQL queries in Haskell, building on Persistent data mappings.
- It allows nearly raw SQL queries with compile-time type checking to prevent errors.
- The tutorial uses a sample chinook.db SQLite database and scaffolds a Haskell project with Persistent and Esqueleto.
- Covers basic select queries: arithmetic, selecting from tables, limiting results, sorting, and extracting fields.
- Filters include WHERE, DISTINCT, LIKE, set membership (IN_), subqueries, and null checks (IS NULL, IS NOT NULL).
- Joins: inner join between tables, and multi-table joins using the new Esqueleto style with monadic bind and pattern matching.
- Data aggregation: GROUP BY, COUNT, HAVING for filtering grouped results.
- The new style (Database.Esqueleto.Experimental) is recommended and safer than the legacy style.
Entropic Thoughts
2 months ago
- This article presents a modular FizzBuzz implementation using monoids in Haskell, combining guards and Maybe values.
- The key advantage is easy extensibility: adding a new rule (e.g., 'zork' for multiples of 7) requires only one new line of code, without altering other parts.
- The expression 'fizz' <$ guard (rem i 3 == 0) produces Just 'fizz' when divisible by 3, otherwise Nothing, and mconcat combines all such results.
- fromMaybe (show i) replaces Nothing with the number as a string, providing the final output for each number.
- This illustrates how generic interfaces like Monoid and Alternative enable modular design beyond just FizzBuzz, scaling to larger problems.
Entropic Thoughts
2 months ago
- The article demonstrates how to support multiple representations of complex numbers (rectangular and polar) using tagged data, inspired by SICP section 2.4.2.
- Initial implementation mimics Lisp with dynamic typing using cons cells, attach_tag, type_tag, and contents functions.
- Constructor functions make_rectangular and make_polar create tagged pairs, and extraction functions use trigonometry for conversions.
- Generic functions (real_part, imag_part, magnitude, angle) dispatch on the tag to handle both representations.
- The code is then refined by replacing dynamic typing with Haskell's static type system: using tuples, pattern matching, and Double values.
- Finally, a native algebraic data type (Complex) is introduced, eliminating custom tagging and reducing code from 80 lines to 30 lines.
- The article notes that this approach is not ideal and hints at data-directed programming as an alternative.
Entropic Thoughts
2 months ago
- The article describes implementing a digital circuit simulator in Haskell, closely following SICP's approach using mutable state and message-passing.
- Wires are defined with IORefs for signal value and action procedures, enabling the observer pattern where downstream components subscribe to signal changes.
- Basic gates (inverter, and_gate, or_gate) are implemented as action procedures that update output wires after a delay, using a global mutable agenda for scheduling.
- Higher-level circuits like half-adder and full-adder are composed by wiring gates together, demonstrating an open and composable component system.
- The simulator uses a global `the_agenda` via `unsafePerformIO` to manage propagation delays, allowing simulation of circuits like a ring oscillator.
- The author notes that while the code is impure, Haskell can still be used effectively with side effects, and future work could explore pure simulations using ST.
LLMs Will Cheese Your Types: Fighting Back in Haskell
2 months 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
Actegories
2 months 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.
Scarf has moved away from Haskell
2 months 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.
Low-level Haskell: The cursed way to emulate inline assembly in Haskell/GHC, or
2 months 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.
Data-Directed Programming in Haskell
2 months 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.
Type-checked non-empty strings
3 months 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.

haskell

Twenty Years of Pandoc

Entropic Thoughts

Entropic Thoughts

Entropic Thoughts

Entropic Thoughts

LLMs Will Cheese Your Types: Fighting Back in Haskell

Actegories

Scarf has moved away from Haskell

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

Data-Directed Programming in Haskell

Type-checked non-empty strings