It is a direct consequence of the core FP principle of referential transparency, though. the temporal context of function execution is irrelevant, so you can avoid evaluating everything until it's strictly necessary. Or you can precompute it at compile time, whatever floats the boat.

@@julians.2597 Exactly, that's why it's a widespread feature, but a consequence is the exact opposite of a principle ;) FP enables lazy computation, but not using it doesn't make it less FP.

and the number of its problems keep growing. Great resource. Thanks for your comment.

I used to write code like that. Then I could never read it again ;). Thanks for the comment.

I came from a Functional programming background, thus I use filter and map. But they are relatively equivalent. For python people, generator comprehensions are more pythonic than filter and map though. Personally, I think it does not matter much, as long as you are using a generator comprehension. I think the difficult part is to get into the habit of stop instantiating lists when it is not necessary. thanks for the comment.

@@dmgerman I had some other thoughts while implementing some of your ideas in a project. I noticed you don’t use type hinting in your videos, any reason for this? I try to use them as much as I can. I noticed the python type system doesn’t really work very well with map/filter. It’s useable, but definitely does not work as seamlessly as my limited experience with Haskell has proven it can be. Another was an observation that you can’t clone generators. I found this while trying to make a function that filters any exceptions from valid objects in a map and returns two separate generators. You can only consume either the valid objects or the errors since the generator is destroyed and they actually point to the same object in memory. It’s made me consider rerouting to list comprehensions so I can keep both. There may be another way that I haven’t found yet to keep both though, just noting a limitation.

I think both are good projects with different goals in mind. For instance, EntilZha/PyFunctional is very Scala-like (which I like very much). I haven't used either one, but I think there is always a small risk of bringing new non-standard dependencies to a project. But if you (and others maintaining your code) like one of them, why not? I might dedicate a video in the future to each library (kind of intermediate level). thank you for your comment.

While I prefer to write code in white background, I can see the appeal to have a dark one while watching a video. Thanks for the comment.

The idea, correct me if I am wrong, would be to create a lambda inside the lambda and give the inside lambda a name (so it is no longer anonymous) and then call this lambda. Probably very unreadable code.It might be an interesting video to try to understand how closures work.

@@dmgerman not exactly, but you're completely right that it would be unreadable. So, you give a name to the outer lambda function and then use this name inside of that same lambda: >>>(fib:=(lambda n: n if n in {1, 2} else fib(n-1) + fib(n-2)))(9) 55

wow. I really need to read the semantics of :=. It means that fib is created _before_ the right hand side is computed, which is very different than a typical assignment (e.g. fib= ...) , where the left side exists only after the right hand side is evaluated. I appreciate you took the time to share it.

@@dmgerman indeed, quite a peculiar sematic. sure, thanks for your content!

this made me laugh 😂 a lambda within a lambda! Thanks for sharing.

Yes, that is the idea. If you have any suggestions for problems to solve, let me know.

​​@@dmgermansomething like a small webserver with sqlite or a text file transformation CLI, maybe CSV -> JSON

thank you for the feedback.

Yeah, I keep making those mistakes. Thank you for the comment.

@@dmgerman I will forever call tuples with 3 values a tuplet.

1000 of depth is not a shallow tree, consider using a balanced tree for such cases.

I never said it was . The important this is knowing the depth because raising the limit is a hack

Thank you for the feedback. I have been considering using a dark mode. I just need to find one that I like.

True. I'll leave that for the advanced videos. Thanks for pointing that out.

Same

Is it just for error prevention?

3NF & BCNF help reduce updating errors. BCNF does so at a lower duplication cost than 3NF

Currently Yomikun only has basic definitions for words (at most one line) that are used for the automatic popups. For the actual dictionary lookups, it uses an external program (currently myougiden); such program is the one that needs to be able to use other dictionaries. It would be easy to add support for other programs (having more than one dictionary backend), but so far, myougiden has been good enough.

He is our professor at University of Victoria! Very intelligent ofc.