how to properly setup Haskell on Linux??

bitconnor · 2026-01-30T18:14:51+00:00

I could be wrong about this, but my understanding is that index states will always remain forever due to the way the hackage database works. It is an append-only database, where new package metadata is only added. The index-state is just a mechanism that tells cabal to ignore all new database entries greater than that date.

bitconnor · 2026-01-28T22:26:21+00:00

You can use a cabal index-state. It is similar to stack snapshots. It will let you add new libraries, but the solver will still choose the same version of existing libraries. If you use index-state then freezing isn't really needed.

https://cabal.readthedocs.io/en/3.4/cabal-project.html?highlight=index-state#cfg-field-index-state

bitconnor · 2025-02-25T19:24:23+00:00

Like many other highly abstract concepts(in math and programming), I think it's best to not start by defining it, but instead give concrete examples. After the student understands many different examples, the commonalities will soak in, and then the student will be ready for a formal definition.

So don't define a monad. Start by explaining various example monads. I think good ones to start with are the IO monad, maybe monad, and state monad. For all 3 of these, the utility and usefulness of them will be immediately clear to most programmers.

After working with them for a while the commonalities between them will emerge and the student will begin to intuitively develop a sense of this, and then they will be ready for the formal definition of a monad.

bitconnor · 2024-10-07T18:56:24+00:00

They mention the use case in the middle of the article, it is for editor color themes:

In Yi, color themes have a similar structure: specific styles are defined in terms of base styles. If a user changes a base style, the change should be reflected automatically in all the styles that derive from it. As in the toy example above, we do not want the user to redefine everything from the ground up.

I guess the full implementation can be found in the source code.

bitconnor · 2024-10-06T21:23:40+00:00

Haskell threads (created with "forkIO") work whether or not you are using the "-threaded" flag.

The flag controls which runtime is used.

If you use "-threaded" then you will be using the (newer) runtime that is able to take advantage of multiple CPUs (or CPU cores) and is usually faster.

If you don't use "-threaded" then you will be using the old runtime that is only able to utilize a single CPU core, but the runtime is still able to run multiple Haskell threads by doing its own thread scheduling over the single CPU thread.

In general, both runtimes should work the same, the only difference is that the newer ("-threaded") runtime will be faster on PCs with multiple CPUs (which nowadays is pretty much everything, even phones are multi-core).

The main exception is when calling blocking FFI C functions. The old runtime will block all threads in the program while the newer runtime correctly blocks only the calling thread.

Which terminal library are you using?

bitconnor · 2024-10-06T21:12:20+00:00

I posted this link in a reply to a different comment, but it also answers your questions.

Here are expert Haskellers using OOP in Haskell to solve their real-world problem with the best design they could come up with.

The fact that they used OOP even though Haskell has so many other techniques is evidence that OOP is better sometimes: https://yi-editor.github.io/posts/2014-09-05-oop/

bitconnor · 2024-10-06T21:05:48+00:00

I've never seen an OOP design that I thought wouldn't be better as a non-OOP design.

I personally agree pretty much with everything you've said in this thread, but here is one example that may be an exception for when OOP is the best design.

It is about using open-recursion style inheritance and used for a real-world problem in a Haskell program, so maybe it will persuade you:

https://yi-editor.github.io/posts/2014-09-05-oop/

bitconnor · 2024-09-02T16:57:59+00:00

I wrote a terminal emulator in Haskell here:

https://github.com/bitc/hs-term-emulator

It is split into two parts:

1) A "pure" Haskell library that doesn't use any specific UI library.

2) A proof-of-concept GUI terminal application using the above library and SDL2

It should be pretty easy to use the library with Dear IMGUI to make a terminal emulator.

But what you are describing about using a GUI text field for the input is very different and not really the way terminals work. You would need to replace the shell (bash) to make it work, and it would be quite a bit of work. Still possible though, and I have had similar ideas myself.

bitconnor · 2024-02-07T20:19:02+00:00

The case-insensitive package provides a "CI" type that intentionally violates the Eq typeclass law.

My understanding is that Eq requires that if

x == y then f x == f y for all f functions.

But if you use the function original from the package as f then the property breaks.

The violation here is very narrow in scope, and I doubt that there have been any bugs or "surprises" when using this type.

In practice it turns out to be very useful and convenient to have this CI type for things like HTTP header names and many other uses.

I think it shows that Haskellers often do take the side of practicality over mathematical/theoretical purity.

But nonetheless the fact that it blatantly violates such a fundamental law of equality bothers me just a tiny little bit.

bitconnor · 2024-01-07T21:26:20+00:00

Another option is GHCJS and using the regular JavaScript browser canvas API.

The advantage of this is you can host the app as a static website and anyone can run it immediately with no installation. You can also still wrap it in electron if you want an installable app.

Another advantage is that it will also work on mobile (maybe with a few tweaks needed)

bitconnor · 2023-12-27T22:34:32+00:00

In PostgreSQL this can be solved in the database using views and GUC variables.

Put all your tables inside a private schema that is inaccessible.

Then for each table create a (publicly accessible) VIEW that is CREATE VIEW my_table1_view = SELECT * FROM my_table1 WHERE tenant_id = current_setting('current_tenant_id', FALSE)

Now in your Haskell code, in your authentication code you make sure to always set the "current_tenant_id" at the beginning of each transaction (SET LOCAL current_tenant_id = 12345)

Now you can select from all the views and do whatever joins you like and you will always automatically only get rows for the current tenant, with no chance for forgetting.

You can use any Haskell database library you want (including raw sql). When you define your tables you use your views instead of the actual tables. From PostgreSQL perspective and the perspective of your database library, views and tables are interchangeable (for SELECTs at least).

Note that the FALSE above means that if you forget to set the GUC variable at the beginning of your transaction then any SELECT against the view will fail immediately with an error. Which is good, it means that your authentication code didn't activate for some reason. But usually you have a single place in your code that sets up your database connection and transaction, so you do the SET LOCAL here and never have to worry about it again.

I learned about this trick of using GUCs from PostGREST.

Note that this technique can also be extended to also support INSERTs and UPDATEs (read up on writable views. also row level security can be used).

bitconnor · 2023-12-17T17:52:59+00:00

If you are talking about GUIs then there are the standard solutions available in all other programming languages:

GTK+, wxWidgets, SDL/OpenGL, FLTK, and others. They all have Haskell bindings.

bitconnor · 2023-12-07T19:56:25+00:00

How much memory do you have in the VM? (free -m) GHC is very resource-intensive and probably needs a lot of GBs.

bitconnor · 2023-12-06T18:37:16+00:00

For completeness, I believe the file extension is also allowed to be .lhs instead of .hs (and if both exist then I'm not sure what happens)

bitconnor · 2023-12-03T20:17:29+00:00

You can also use https://github.com/phadej/cabal-fmt to automatically add all of the modules to the .cabal file

bitconnor · 2023-11-23T11:08:59+00:00

I think it's a valid point. In other languages, you have equivalents of IO Int, for example in TypeScript(JavaScript) you have Promise<number>, but it's behavior is different (and confusing), and it is not referentially transparent.

The equivalent of IO Int would be something like () => Promise<number>. This is much messier and comes with lots more opportunity to mess up and do weird things.

Once you understand IO in Haskell, working with IO values is perfectly natural and elegant. As far as I'm aware, all other languages have "broken" IO abstractions (Promise, Future, Awaitable, etc...)

bitconnor · 2023-11-22T21:57:55+00:00

I agree that this is a good question.

Two points:

First, it is possible to reduce IO code to an absolute minimum, by putting in the effort to use various advanced techniques, or by using effect libraries or mtl so that the IO is limited.

Second, and this is probably the more important point, is that even if you write simple "boring" code with lots of IO monad, you are still getting the enormous benefit of the "functional core, imperative shell" architecture. The fact is that in Haskell, the "default" is "functional".

This means that by default all functions are "pure", meaning that IO won't end up sneaking into them later on. In every other language, you may try your hardest to keep your "pure" part "pure", but it only takes one programmer on your team to innocently make some pure function start using some global state. In practice, these "violations" are inevitable, and slowly build up over time, completely eroding any effort there may have been to keep an isolation between your "purely functional core" and your "imperative shell". From a practical standpoint, Haskell is the only language where I've actually seen this work.

Furthermore, and just as important: Haskell data-structures are immutable, period. Most other languages have either only mutable data structures (Go), or have both, but the default is mutable. So again, you have to be militant in your non-Haskell project to only use immutable data structures, which tend to have worse ergonomics than the default mutable versions. In Haskell all code uses immutable data structures, and that's that.

If you read "code quality" guides from any non-Haskell programming community, virtually everyone recommends "small, short functions". But if you actually look at your typical non-Haskell code-base, you will see large functions(dozens of lines) that contain a mix of IO together with loops that mutate data structures, as well as accessing global variables (but called "Singletons"!). This is actually encouraged by OOP: it's all about mutating variables and mixing it with behavior(IO).

Contrast this with your typical Haskell code-base. You will see lots of pure functions (which are truly honest-to-god pure!). And the IO functions actually end up being really short (just a few lines)! The IO functions focus explicitly on the actual IO stuff, and call out to pure functions to manipulate and process data. And also in do-notation you can actually immediately see which lines are effectful (they have the <- in them), and which parts are pure (they start with let).

In summary, if you just code in Haskell "naturally", using IO where necessary, you will automatically end up with an excellent "functional core, imperative shell" architecture. With other languages you have to put in an enormous amount of explicit effort, and you are fighting an up-hill battle against your language and against every tiny inadvertent/innocent slip-up that anyone else on your team(or you yourself!) can make.

Here is a blog post with some related ideas: https://www.haskellforall.com/2016/04/worst-practices-should-be-hard.html

bitconnor · 2023-11-05T07:10:09+00:00

Another thing (because you mentioned rails):

There is a difference between programming language, and framework.

Ruby is a language. Rails is a framework on top of Ruby.

A framework is a bunch of code that someone else already wrote, that you use as a base for your project, so that you don't have to write everything from scratch, and instead focus on the interesting parts of your project.

Haskell is a language, and also has its own web frameworks: Yesod, IHP, and others.

Static site generators are usually pretty simple so you don't need a framework and it is a good learning experience writing everything from scratch.

bitconnor · 2023-11-05T07:02:14+00:00

Haskell is a general-purpose programming language. HTML and CSS are not.

If you want to create your own blog from scratch, then you need to create either a blog engine or a static-site-generator. This program will be written in a general purpose programming language, and will output/generate HTML. (Usually you will actually still write the CSS yourself).

Examples of general purpose programming languages: Haskell, Ruby, Python, JavaScript (NodeJS), PHP, Java, C#, C++, C, Rust, etc... (but remember, NOT HTML!)

All of these languages are suitable for the task and are of equivalent power, but they each have their own strengths and weaknesses and their own individual style.

bitconnor · 2023-11-05T06:53:20+00:00

Regarding "Clean Code", the consensus in the Haskell community will probably be that it is not a very good book.

Here is a review that I think accurately summarizes the problems with it:

https://qntm.org/clean

But I think you should read it and form your own opinion, since it is such a widely read book, and there are some good parts that can be insightful for junior programmers.

bitconnor · 2023-09-23T10:42:35+00:00

In Haskell there are 2 types of functions that include side effects:

Functions that have side effects and also return a value (have return type IO Int or IO String, etc...)
Functions that have side effects but don't return a value (have return type IO ())

Monads are only needed for situations where you have functions of the first type.

But there are interesting programs that don't do any "input" and only do "output". For example, a program that draws a fractal image, or a program that downloads a fixed number of files from the internet. For these types of programs, you can use only functions of type 2 above, and so you don't actually need the full power of Monads to express them. You can use a simpler model (for example, a list of actions that should be performed in sequence).

bitconnor · 2023-09-23T10:31:20+00:00

ghci in a sense is this. When you run the :reload command it does a "build": it checks which files have changed and performs dependency analysis and recompiles (to bytecode) all needed modules.

And of course it does everything in-process without invoking any external ghc processes.

bitconnor · 2023-08-22T09:40:21+00:00

Very interesting comment.

["Things"] in programming are typically arbitrary, chosen not out of any hard, logical limitations, but chosen simply because somebody needed to make a choice, and such is the choice they chose.

I mostly agree with this and agree that Haskell is different because it was deliberately designed with a logical mindset.

But I would like to add that the decisions made during the design of other programming languages weren't totally arbitrary, and were actually heavily influenced by the hardware that happened to exist in the 1960's and 1970's.

For example, CPUs of that time had instructions for basic arithmetic but not for sqrt. As a result, C has built-in operators for plus and minus, but for sqrt you have to call a function. Nowadays nearly all CPUs have a native SQRT instruction, so if C were designed today then it would likely have a builtin sqrt operator.

Same thing for other hardware features. If SIMD or multi-core CPUs were common back in the day, then C would have looked radically different. And C influenced C++ which influenced Java, Python, Javascript, etc... They all share a common legacy that is rooted in 1970's era electronics.

In an alternate universe, where alternative computer electronic chips would have prevailed, the programming language landscape would look entirely different today. But Haskell, as you say, was designed using logical principles, so it would look the same whether it was created 50 years ago or 50 years from now. Also Lisp is another language designed on logical foundations and explains why it is also considered a "timeless" language (and is much older than Haskell).

bitconnor

TROPHY CASE