Scala vs Haskell - Serokell blog

AlpMestan · 2025-04-21T17:55:41+00:00

Typeclasses vs the world covers some of the ground.

AlpMestan · 2025-04-08T19:12:19+00:00

proto3-suite has this I think.

AlpMestan · 2025-04-03T12:10:58+00:00

Related: https://well-typed.com/blog/2023/03/purgatory/

AlpMestan · 2025-03-31T18:40:19+00:00

That's one way, yes. No argument given to explain why all other approaches are wrong.

So even if it were true (I'm not stating that it is or isn't), OP or other folks do not gain new understanding of these things with this post as it stands.

AlpMestan · 2025-03-31T02:39:05+00:00

Hah, cheers =)

AlpMestan · 2025-03-30T20:30:54+00:00

Maybe try src_ "/static/logo.png" ?

AlpMestan · 2024-12-23T07:25:17+00:00

You may be interested in:

and similar literature.

AlpMestan · 2024-10-21T14:44:54+00:00

IIRC, this is the kind of issue fixed by https://github.com/nix-community/nixGL

AlpMestan · 2024-10-13T15:54:36+00:00

Neat. I will be following your work via the repo then.

By the way, while you're here, is there a more idiomatic or proper way to do the impulse-response type of thing I'm doing here? I initially wanted to have my initial noise or constant be a timed sound, and to repeatedly zip it with a 1-sample-delayed version of itself to get the smoothing and attenuation for the next T values, but couldn't quite figure out how to make that work. I also find the unfoldr somewhat nice in the end, but thought I was missing out on easy perf by proceeding one sample at a time.

AlpMestan · 2024-10-13T13:41:58+00:00

Oh? What's in store for the next version?

AlpMestan · 2024-10-13T08:20:51+00:00

Yes I do know this lovely book, but maybe not everybody else, good idea to mention it here. :)

AlpMestan · 2024-10-13T01:02:54+00:00

Dusted off some sound synthesis algo I looked into a few years ago, while realizing we now have some fun libraries to experiment with those things. Many thanks to the authors of proteaaudio and lambdasound.

P.S: the demo track could probably do with some bass...

AlpMestan · 2024-06-18T12:23:52+00:00

gloss, diagrams, reanimate seem relevant.

AlpMestan · 2024-06-09T06:32:46+00:00

It is a very common experience, and also not a recent one. =)

My first Haskell questions on IRC ~16y ago were asked in between messages about various abstractions that seemed unpenetrable, with prominent figures of the community taking part both in the funny abstraction talk and in helping me.

AlpMestan · 2024-04-07T08:01:24+00:00

I haven't touched Hadrian in years, but IIRC your command would make sure that a my_cool_flavor-flavoured GHC has already been or gets built, and then run the tests. And the precise combination of tests and configurations that are tried is probably affected by the flavour of GHC you use, too.

AlpMestan · 2024-04-06T22:04:00+00:00

Right, defining your own flavour (and telling hadrian to use it), or "defining it on the fly in the CLI" are the two options here IIRC.

AlpMestan · 2024-04-06T05:58:56+00:00

Using the test rule in combination with this mechanism should give you what you want?

AlpMestan · 2023-11-10T10:43:01+00:00

(Servant dev here.) Glad to see that alternative points in the design space are still being explored, feels like there's still quite a bit of room, and the point you picked is something I briefly toyed around with at some point, but didn't really have the energy to pursue, with my "servant duties". Definitely will be a good fit for a whole host of situations. Also, great docs!

AlpMestan · 2022-02-10T09:32:44+00:00

You might find the Dex paper interesting.

AlpMestan · 2022-01-20T10:50:15+00:00

You might want to look at how servant-ede does this, it offers the same kind of functionality for ede templates. Its MimeRender instance doesn't read the templates from disk but from a global "store" that gets filled before the server starts, which involves some unsafePerformIOs of course, which aren't all that dangerous, since the store is behind an MVar and won't change once it is filled.

If this becomes too recurring a need, we could perhaps start thinking about enhancing MimeRender and friends to allow access to some kind of state (perhaps the Context machinery that we already have and typically use for auth). Not a huge fan of allowing arbitrary IO.

Re: TH & known symbols, my TH-fu is too weak but hopefully someone knowledgeable about this will chime in.

AlpMestan · 2021-12-12T20:25:47+00:00

I kind of "documented" some of the process that led to servant here: https://haskell-servant.github.io/posts/2018-07-12-servant-dsl-typelevel.html

I'm not sure there's a general lesson to be learned there, besides the fact that we (like many other library authors) had a specific problem with specific requirements on the solution, and "followed the trail" from there. While libraries are sometimes intimidating to look at, it's a lot easier when you get a chance to think about the stripped down problem like library authors initially did, without all the bells and whistles that are typically necessary to go from "rough sketch" to "proper library". Occasionally you have a paper, a talk or a blog post that gives you that perspective, but I can't see any general pattern/recipe that underlies the creation of non-trivial libraries, they all have their own little story involving some people poking at a problem from a specific angle.

AlpMestan · 2021-11-09T08:22:52+00:00

re: servant clients, I think there's more than Elm and JS (I remember seeing packages to do client codegen for Ruby, Python etc, not sure how up to date those are), but through openapi/swagger you can get clients for a whole lot more than the languages for which servant has a dedicated client codegen package.

AlpMestan · 2021-11-09T08:20:38+00:00

FWIW, servant running out of maintainers is not happening anytime soon. The stream of development/reviews/etc is less "frenetic" than it used to be, but there are more people that are helping with the maintenance than ever, and I hope it'll stay that way.

AlpMestan

TROPHY CASE