วีดีโอ

Why don't you use tabulate to define positions, so you don't need that Applicative instance? poaitiona grid = tabulate $ \i -> (index grid i, setter i grid)

I have been watching all your Haskell videos, the advanced ones as well as the introductory ones. They have all been an immense help. I am working on a major ML project right now that I am writing in Haskell, and I want to leverage the power of Haskell as much as I can. Please keep up the good work. Sad you don't get a lot of views, but it is always about quality, not quantity.

Love the Saturn V rocket!

Cool to see Representable used on a non-trivial example. One way of thinking about Representable is that the index type is like a logarithm of your data type (if you visualize the function type i->a as an exponential a^i). Three and Grid are both product types, and you can always take a logarithm of a product--you get a sum. As you mentioned, list is not representable because it's a sum type: List a = 1 + a * List a. An infinite list, on the other hand, is an infinite product, so it's representable.

Great video as usual! I have a question regarding performance overhead: can GHC optimize away the Distributive/Representable for Grid and obtain something similar to the initial hand written code? I initially thought yes because all the functions involved are non-recursive, but then realized that the indices IxThree exist at run-time representations and GHC will not be clever enought to optimize it way.

1:49 - Me learning Haskell

If any audio suggestion, you can use a quieter keyboard for video

Great video Andres!

Thank you Andres! Following you since the haskell courses for IOHK.

Thank you for such a clear, systematic, and elegant way of building up instances!

Indeed, very nice. I'm watching these introductory ones just in preparation for later subjects but I still enjoy them. Someone mentions sound issues, and while those might be annoying for the respective person, I found the lectures easy to listen to and clear, even while playing 1.75x.

Thanks for this great demonstration!

It was thanks to a video explaining monads through the operator <=< that I understood them (maybe from Bartosz Milewski??)

thank youu for amazing insightful content i love that you take time to explain thought process like a real programmer

hey just dropping and i am sorry that i forgot to comment in previous videos but your channel is just absolute treasure i learnt a lot of haskell and how to think in haskell way from you please keep going , also make videos on some hot topics like How rust programmer can pickup haskell how c programmers can benefit etc .... that will help the channel to grow and also a new perpective of thinking to many of us , thank you so much

Thanks for the example. Do you have more examples about the monads like Timed ?

Great content as always. Your channel deserves to be bigger. Please heed my advice: remove access to the older livestreams and then you upload the recordings instead, as regular videos. Upload one episode every 4th day on the spot. You will be Amazed of the views and subscriber count after a couple of weeks. You can use the timer feature so it's not much work. I got from 0 subs to 20k in ten months. JB

Great video! I like the choice if using composition rather than bind and will try it whenever I teach monads again. Also: kudos for showing the importance of laws as a way of enabling refactorings. I'd just like to add that laws are also useful for reasoning about functions that operate over general monads e.g. sequence or foldM.

Great ep! Is it possible to provide a more sensible instance for Monad in the Timed example? Link to the 'Laws' episode mentioned @ 28:48 - th-cam.com/video/V7673JaWXaA/w-d-xo.html

Great way to introduce the Monad. I never thought about it this way. Saying it is composition of two programs also makes a lot of sense and avoids the common Monad container analogy.

Thank you for the great video! It was very helpful.

No i don't

These videos have been fantastic so far, but this one has been particularly helpful. I've read a lot about 'return' but this really solidified my understanding.

Ah, I finally understand how IOError and catching errors works! Thanks :) From the looks of it, you could define several different error handler functions that handle different errors and use that in the (IOError -> IO a) part.

10:00 I wish there was a notion of a lens in Haskell...

I wonder how Andres runs the comments on repl as comments on vim

very very good

Top tier haskell content, absolutely love it. Keep it up!

Thanks for the new video. Some of you might also like to checkout the "Haskell Tiny Game Jam 2023", which has also a few board games written in under 10 lines :)

Thanks for your effective , great content and your straight forward explination. Keep up the brilliant working Mr , haskell is awesome

@7:02 how did you get "forall s a" to populate in the right spot on the lines below with one motion?

You could have made Three and Grid instances of Applicative - then the initial grid would just be pure Empty, and it might have other advantages as well.

this was so nice! i’ve implemented this exact algorithm for tic-tac-toe in haskell but with a totally different (maybe less interesting) representation so it was really cool to see a different perspective. thanks

Thanks for this! :)

Thank you

Hi Andres, one aspect I'm curious about is *adoption* of the Num typeclasses. What proportion of Haskell libraries are written in terms of abstracted Num types, vs just using concrete types like Int, Double etc? Would you nominate any "exemplary" examples of Haskell libraries written in terms of abstracted Num classes, that demonstrate best practices applied?

Great content! Your deep experience makes all the difference with this sort of topic..

Right after watching this video I started watching a presentation (titled "polynomial interfaces") which mentioned how a UI in Elm is defined by an update function, an initial function and a view function, which happens to match the type signature of the Fold type from the foldl library (update=step and view=extract). I would probably not have noticed this connection if I didn't watch these two videos directly after each other. This makes me wonder if the Fold library could also coincidentally be useful for defining user interfaces, where a scan over the stream of events would be how the Fold is consumed. I guess this is also somewhat related to the concept of FRP which Elm was initially based on.

A very minor question: I was looking through the source code for function generation and was wondering why this line: abstract (Prod p) d (x,y) = abstract (fmap (\q -> abstract q d y) p) d x wasn't instead defined as abstract (Prod p) d (x,y) = abstract (abstract p d x) d y which seems simpler and avoids traversing the data structure an extra time?

A couple of questions have come to my mind near the end. Is there a strict counterpart to the Identity monad? Is there (or can be written) a monad transformer that makes any monad strict? Would this transformer commute with all possible transformers? In a universal way, i.e. with a pair of mutually inverse isomorphisms between their compositions in different orders?

I really like that thinkInfo is now showing the source location! Productivity tip: Did you know, that when the terminal in vscode is showing reference to a line of code/src span (like app/Main.hs:32:28-38 at th-cam.com/video/NTW62s3mrXQ/w-d-xo.html in the video), you can actually ctrl+click that reference to jump to the referenced code? A huge time-saver, when using things like ghcid or ghciwatch from vscode..

This is probably an orthogonal issue, more related to performance, but I wanted to check: the solution here forces the results inside the function passed to modifyMVar_, which means that all accesses of the state need to wait for that evaluation to complete before the MVar is filled. If you were doing this in production, would you instead use modifyMVar, and then force the return value after the MVar has been written to, a la atomicModifyIORef’? The only downside I can see is that if the evaluation causes an exception to be thrown, that will have been written to the MVar and not caught by the (presumably) bracket call modifyMVar is implemented with. It seems like a beneficial thing to do if you can be sure the update function can never produce an exception.

Being a pedant, but there is a valid function from a concrete type to a polymorphic type, namely `absurd: Void -> a`.

Really nice lectures. Thanks.

Cool stuff! Previously one could already get backtrace info on exceptions in profiling builds with +RTS -xc, but that was very noisy in practice because it prints a backtrace for _every_ exception - and it's often not even clear which of those exceptions is the actual problem. Having an easy way to get good backtraces for mostly only the exceptions that matter is definitely a boon for debugging!

Good underrated language.

I only really know PureScript but wouldn't it be faster to use something like STArray and allocate a list with the same size at the start and walk over the original structure backwards and copy the cells over? Maybe there's some kind of memcpy that works backwards?

thanks for making this! is there some way to use this to get a backtrace from an operation that's in an infinite loop seemingly? I tried throwTo to that thread and catching higher up, but the ExceptionContext is empty

very detailed explanation!!

Great video. I was trying "annotateIO" in a program run with runhaskell/ghci and I didn't saw any annotations. They only appeared when running the compiled program. I suspect it's because the "losing annotations when re-throwing" effect described at 9:50.