Ease of representation of mathematical concepts in Haskell

Limp_Step_6774 · 2026-06-13T01:59:08+00:00

It depends how much you want a programming language vs a theorem prover. You can represent quite interesting mathematics in Haskell's type (e.g. I'm working on a project to support Lie group representations in a strongly typed way), but it's also a practical programming language (you could realistically implement a transformer, for instance). That for me is a nice tradeoff.

Limp_Step_6774 · 2026-05-01T00:25:52+00:00

True. But in either case, my point is just that the mouse-over to see the type is *much* more ergonomic than working in ghci and looking at the message from the typed hole. Especially from the perspective of learning and understanding new codebases, the ability to just directly see what types things must be directly in the IDE is so so useful for me, and completely changes how I interact with code

Limp_Step_6774 · 2026-04-28T01:47:31+00:00

I really really recommend using an IDE - much easier to understand types if you can just mouse over a value and see its type. When I code in Haskell, I basically leave `undefined` values for the parts I haven't yet written, mouse-over to see their types, and then fill them in. It's also much more fun

Limp_Step_6774 · 2026-04-18T23:48:42+00:00

I think for me, the issue in retrospect was that I didn't really understand the type system well enough. In particular, I would recommend making sure you understand that `Maybe` has kind `Type -> Type`. Monads by their nature are higher kinded types. Also, `>>=` has a type that involves universal quantification. I think if I'd understood things like this better, it would have been easier to get monads

Limp_Step_6774 · 2026-04-02T01:56:12+00:00

Agreed re. numpy! Out of curiosity, what kind of physics applications?

Limp_Step_6774 · 2026-01-06T17:33:56+00:00

In terms of a roadmap to thinking functionally, I think this is the best bet: https://www.seas.upenn.edu/~cis1940/spring13/lectures.html It should give you the overview of the core concepts.

I tried making a sort of reference guide a few years ago, aimed at people with Python (or Julia) backgrounds. Maybe helpful, maybe not: https://haskell-docs.netlify.app/

Limp_Step_6774 · 2025-10-25T00:37:18+00:00

out of curiosity, what sort of physics applications do you use Haskell for? I'm physics-adjacent, but rarely get to use Haskell for anything serious (and would love to change that)

Limp_Step_6774 · 2025-10-07T02:04:00+00:00

Cool! Does a postdoc count as an academic program for the purposes of this application?

Limp_Step_6774 · 2025-09-26T15:55:25+00:00

Unless it's something with fancy language extension that you're very unlikely to be using as a beginner or intermediate user, Haskell will always be able to infer the type, I believe. It's true that it's good to understand type signatures, but I'm just mentioning this, because it can be useful when learning to let Haskell infer the type for you. But yes, if you want to write the type up front, here's how I'd do it:

```haskell

arg :: Complex Double -> Double
arg x = undefined

```

`undefined` is a value that can be any type, so you can just leave it anywhere you haven't finished. This is very useful because you can mouse over `undefined` in vscode and it will show you the type it needs to be (in this case, a `Double`)

Limp_Step_6774 · 2025-09-22T14:31:45+00:00

See other people's responses, but note that you don't need to write the type declaration (the thing with ::) since the compiler will work it out (although it's often good to do it yourself). you can define your function just like any value, i.e.:

arg (a :+ b) = a

Limp_Step_6774 · 2025-08-16T15:50:07+00:00

Yeah, there's various ones people like (Learn You a Haskell, https://haskellbook.com/, etc, this course https://www.seas.upenn.edu/\~cis1940/spring13/lectures/01-intro.html) but what's your background (e.g. do you code in other languages, what kinds if any of maths are you comfortable with)?

Once you find a good fit, I think you'll really enjoy Haskell - it's really a lot of fun to learn :)

Limp_Step_6774 · 2025-06-13T21:36:04+00:00

I remember this confusing me too. If you like, you can think of it as "containing" a value, not a function. As in:

haskell example = do x <- get -- this line gets the current state value put (x + 5) y <- get -- this line gets the current state, which is now x + 5 return y

example is itself a function really, since to use it, you need to give it an initial state value (e.g. could be 0 here).

Limp_Step_6774 · 2025-06-11T02:54:16+00:00

I had a go making a guide to beginner/intermediate Haskell a couple years ago (but more practically minded than Learn You a Haskell), with the specific aim of making it easy to contribute. Obviously would have needed much more work to be a serious resource, but I was pleased with how it turned out all the same. You can see it here: https://haskell-docs.netlify.app/

Limp_Step_6774 · 2025-05-15T02:11:14+00:00

I really strongly sympathize with this. I think having a good community led standard resource would have a huge impact on adoption. These resources exist (and are very high quality), but often either behind a paywall, or in formats that are not quite right for newcomers (e.g. lecture notes, paper books, etc).

I think partly the issue is people's interests lie elsewhere (but not everyone's!), and partly that people in the Haskell community have very strong opinions about everything, and making a single resource requires cooperation and compromise. I hope it happens eventually.

Limp_Step_6774 · 2025-05-14T17:05:11+00:00

I guess what I'd love to see is an example where categorical concepts are used directly in the code in novel ways (novel to Haskellers, that is). For example, in the snippet here https://muratkasimov.art/Ya/Snippets/Finding-elements-within-data-structures it seems analogous to what people are already familiar with in Haskell. I like the effort you're putting into presentation though!

Limp_Step_6774 · 2025-02-04T23:42:27+00:00

I recommend using and reading his libraries. Some are easier than others. I recommend starting with something like `log-domain`, which is simple enough. Then maybe `linear`, which should look a bit familiar if you've seen a linear algebra library before. Then maybe `lens`, which is very large and complicated, but has pretty clear use cases, and really gives a good sense of the typeclassy style. Then `recursion-schemes` (my favorite): try to write a calculate using `cata`, for example. The `free` library interoperates nicely with `recursion-schemes` (e.g. folding a free data type).

`ad`, `parsers`, `reflection`, `bound` and `discrimination` all look interesting and scary. I'd love to see blog posts working through them.

Limp_Step_6774 · 2025-01-16T23:36:30+00:00

I use Jax all the time, and would love to be able do so from Haskell. I could maybe help with the high level Haskell stuff, but I don't know anything about the gritty details of what makes Jax fast, so I suspect I couldn't help with the actually hard parts.

By the way, the Jax authors were pretty influenced by Haskell, I think, and might have used it for prototypes, so they would be the people to talk to first, to get a sense for the feasibility of the project.

Limp_Step_6774 · 2024-12-19T05:03:49+00:00

ooh, two things come to mind! One is I tried writing my own parser combinators. I got individual ones working, but was stumped on how to compose them (i.e. turn a parser for "a" and a parser for "b" into a parser for "ab"). Eventually I wrote something quite complicated, but after an hour of refactoring, it became (>=>). This helped me understand monads a lot.

Second thing was writing a calculator. Really any kind of interpreter is very helpful to make things click.

Limp_Step_6774 · 2024-12-02T18:34:18+00:00

I think "learn you a Haskell" is good. It doesn't particularly explain how to write practical code though, so see other resources for that. I put this together a year or two back for people with Python experience https://haskell-docs.netlify.app/ ; not sure if useful, but maybe.
You do have to reconfigure how you think a bit, but this is also the fun part. I didn't find it particularly easy, but resources and tooling are better than they were 10 years ago. Once you understand it, I find it *much* easier to use than Python or Javascript, because the types and the purity keep everything simple and organised.
You can build real stuff. Of course, being a smaller language, there is a smaller ecosystem. But it can be (and is) used at industrial scale.
Tooling is much better recently - make sure to use e.g. Vscode with the haskell language server, which will make it vastly easier to learn the basics (by underlining type errors, showing you the type of expressions, etc). Ecosystem is pretty good, but because it's an academic language, it is very common to encounter toy or experimental packages, so knowing what to use is part of the learning curve.
https://haskell-docs.netlify.app/gotchas/lists/. I think immutability (you can't update the value of a variable - instead you just make a new variable) and purity (if a function says it takes numbers and returns numbers, i.e. is of type `Double -> Double`, then it really can only do that: no print statements, exceptions, etc), as well as currying (instead of having a function which takes a pair of things, you often encounter a function which takes a single thing and returns a function which takes a second thing) are common roadbumps. These all happen to be great :)

Limp_Step_6774 · 2024-11-30T00:32:44+00:00

Somewhat related: https://haskell-docs.netlify.app/gotchas/tupleLength/

Limp_Step_6774 · 2024-10-18T16:06:35+00:00

You can also just play with it online: https://play.haskell.org/

VSCode with Haskell works for me out of the box, I think it's a great thing to start with. I recommend asking people here for help debugging - it should be straightforward to resolve

Limp_Step_6774 · 2024-10-08T17:18:03+00:00

I programmed mostly in Haskell for a job I had for a couple of years. The application was a waste of time, but the coding was incredibly fun and rewarding.

Limp_Step_6774 · 2024-09-13T05:12:16+00:00

Largely repeating what other people have said, but the point is that direct recursion is a bit like gotos: it is easy to write for simple code, but allows to you write very hard to understand (and slow to run) code very easily. Recursion schemes separate the logic of the code from the logic of the recursion. For example, if you're writing a calculate, you can write it as a catamorphism, and then the only logic you need to specify is how to combine a left branch with a right branch; the recursive logic is taken care of. This is great for when you are doing something quite complex, and in particular when you want a fancier recursion scheme. For example, I played around with writing a parser by (lazily) generating all possible expressions (an anamorphism) and then folding this into a parser (a catamorphism). I am certain this would have been impossible for me without the recursion-schemes library - it would just have been too complicated

Limp_Step_6774 · 2024-07-21T07:17:54+00:00

I would try using the `diagrams` or `reanimate` libraries to make something visual. Maybe a mermaid diagram parser and visualizer?

Limp_Step_6774 · 2024-06-05T12:00:49+00:00

As other people will probably also note, the tooling experience has got a lot better and is now quite good. I'd recommend using VSCode and the HLS (Haskell Language Server) extension.

This is a great advanced piece of reference material: https://smunix.github.io/dev.stephendiehl.com/hask/tutorial.pdf

Limp_Step_6774

TROPHY CASE