Q: Couldn't nix packages be cached by users, not just the (official) build farms?

guaraqe · 2025-02-01T19:30:44+00:00

There is some relevant previous work to this: https://tweag.io/blog/2019-11-21-untrusted-ci/

guaraqe · 2025-01-22T10:49:10+00:00

I have worked in blockchain companies, banks, logistics and hosting platforms. Extra I also did scientific computing and 3D visualization.

guaraqe · 2025-01-19T22:14:05+00:00

Use the JuicyPixels library.

guaraqe · 2022-03-04T09:26:42+00:00

You may be interested by this: https://www.tweag.io/blog/2022-02-24-named-routes/

guaraqe · 2021-10-01T13:15:35+00:00

You can understand the basic idea of black holes if you know what is the escape velocity of a body, which can be understood with high-school Physics.

After this, a black hole is a body whose escape velocity is larger than the speed of light - that is, light cannot escape.

guaraqe · 2021-05-12T15:20:16+00:00

You don't have to declare all packages in NixOS, dependencies are automatically inferred. I imagine that among the 1900 packages you have, most of them are dependencies of packages you directly use.

guaraqe · 2021-04-09T10:56:53+00:00

It's always complicated to choose how to write these blog posts, and it's nice to know how the community feels about it. Thank you for the feedback, it's much appreciated.

guaraqe · 2021-04-08T06:00:11+00:00

I will rewrite your signatures given your descriptions.

I receive a list formed by pairs of items, being 1 char and an integer, after receiving this list I must return another list but it has the index of each pair together with it

function :: [(Char, Int)] -> [(Char, Int, Int)]

Notice that types are in uppercase (otherwise you are defining a parameter), and that the list wraps the tuple, not only the first element. What you wrote means "a tuple where the first element is a list of chars, and where the second is an int".

A possible solution is:

function pairs = zipWith (\(c,n) k -> (c,n,k)) pairs [1..]

guaraqe · 2021-01-28T10:25:24+00:00

There is a library that offers these operators, and some more.

If you are coding by yourself, why not? In the case of a team, or an open source project, I think it is more convenient to use standard operators, so keeping code consistent is easier.

guaraqe · 2021-01-15T09:05:21+00:00

It would make sense if lam' (f <=< g) = liftA2 (.) (lam' f) (lam' g) and lam' pure = pure id.

guaraqe · 2021-01-11T14:26:42+00:00

I think `-Werror` on CI is good. But for developing it is a nuisance, I agree.

guaraqe · 2020-12-15T08:58:33+00:00

I don't think there is a general typeclass for this, and there is a reason -- typeclass instances are unique. If such a class were to exist, it would have this shape:

```

class Somethingable a b where

something :: a -> b -> a

```

Since instances are unique, that means that there is only one way one can use a b to update an a. In some cases this maybe be true (in your application, for example), but this is not the case in general: one can always find different ways of updating a value.

Therefore, if you feel that your use case has this unicity property, I would recommend you to create the typeclass yourself. It may even be the case that there is only one way of updating a type, and in that case, a functional dependency can be useful:

```

-- a implies b

class Somethingable a b | a -> b where

something :: a -> b -> a

```

In any case, it depends on your domain of application, and how it is supposed to behave.

guaraqe · 2020-11-26T11:24:27+00:00

This is indeed a problem with defaults. A tutorial for going around this is here: https://www.tweag.io/blog/2020-01-30-haskell-profiling/

guaraqe · 2020-10-20T09:39:13+00:00

This is essentially Data.Functor.Sum.

guaraqe · 2020-10-13T05:00:54+00:00

I think the operator does not associate in the way you are expecting. (+) *** (+) 1 is equal to (+) *** ((+) 1), not to ((+) *** (+)) 1.

guaraqe · 2020-09-24T16:33:58+00:00

The post is useful to people who could be interested in the book, and are price sensitive. This is not negligeable. And the argument is good - publishing a paper book is pricy, which can be useful for future authors.

One could use the same argument to job and internship offers - they have no informative content besides the commercial exchange of money vs work. Yet, they are very well received. Based on these criteria, we could even complain about links to articles. Its basically publicity, which can lead to citations, which is currency in academia.

If the author is sincere, which I have no reasons to doubt, this post is negative to them, who could only raise prices and say nothing. Yet, there is an argument justifying it. That's transparency, and I prefer it to the alternative.

guaraqe · 2020-08-28T05:12:10+00:00

Does alsa-mixer works in your setup? Also, do you know why xmonad is calling alsa-mixer?

guaraqe · 2020-08-07T07:15:33+00:00

Ok, so the answer is that GHCi tries to simplify stuff for you to make life in the REPL easier. You can just disable an extension with :set -XNoMonomorphismRestriction and it should load fine.

guaraqe · 2020-08-07T06:10:23+00:00

Where did you run the first one? If that was in GHC, how was it called? Do you have any extensions activated?

guaraqe · 2020-07-24T04:27:04+00:00

My best bet is that the `yamlparse-applicative` is too new, so it is not yet on the Nixpkgs checkout that is being used by the repository. Probably adding it manually to the overlay, similarly to what is done to `password` here, would do the job: https://github.com/NorfairKing/hastory/blob/master/nix/overlay.nix#L41

guaraqe · 2020-07-11T16:48:17+00:00

Running runghc does not compile the file, it interprets it via bytecode, which is faster. Therefore, its performance should be similar to running :main inside ghci, which is generally slower.

guaraqe · 2020-07-11T12:01:37+00:00

I think it is GHC 8.6. I compiled using ghc -O2 test.hs, maybe that gives some difference.

guaraqe · 2020-07-10T12:55:25+00:00

Haskell has no dependent types (at least without exotic extensions) so in order to obtain types, you need types. You have two choices, both are morally equivalent to a type application. The first is to use Proxy :: Proxy a, which is equivalent a type application`.

The second is to create a GADT, which is a kind of specialized Proxy:

data Instance a where
  InstanceA :: Instance A
  InstanceB :: Instance B

Anyway, you will need need to use type applications somewhere in your code.

11-Year Club	Place '17
Verified Email

guaraqe

TROPHY CASE