JSON Parser 100% From Scratch in Haskell (only 111 lines) 

absolutely. I heard "emacs" and despite already assigning this guy the "dope tech 'tuber" label he gets the rare "speaks to my soul" label too

Couldn't agree more. Great channel!

My thoughts exactly! I've read lots of Haskell books and even written a clumsy parser, but this guy is amazingly good in explaining things

"Study this video for a month" this statement doesn't give Haskell a very nice look.

And I still won't know how to indent properly SO IT COMPILES (1:35:03)

i studied it for a month. still didnt understand. moving on to php now.

did you pass?

Where do you study?

@@krishnasivakumar2479 yep, managed to get it done haha

@@solopernumeri2 University of Toronto

@@Ahmad-if1tt awesome, kudos! What was your grade?

Can your python do that?

it’s nice that learn you a haskell is free but it’s not really a great book IMO. i have no idea why the first pages of the book are all haskell syntactic sugar and other garbage that has nothing to do with the core of what haskell is (the language) and how to program with the core of the language

@@michaelthompson7217 agreed. I'm not really sure who LYaH is for, tbh I guess it might be okay when it's used in a University course, alongside a lecture and some assignments-I end up referring to it sometimes, for examples of things, and I guess it would serve a similar function for someone who has to pass a class

I'm intrigued. Can you expand on this?

@@unsafecast3636 According to hackage.haskell.org/package/base-4.14.1.0/docs/Control-Applicative.html A valid applicative needs to satisfy the following laws, some of which are not expressed in the implementation. This means you could write an Applicative instance of a type and have it compile in Haskell, but it doesn't necessarily mean it's mathematically a lawful / valid applicative. Identity: pure id v = v Composition: pure (.) u v w = u (v w) Homomorphism: pure f pure x = pure (f x) Interchange: u pure y = pure ($ y) u

@@chon-850oh okay. Thanks

That could be great.

What's this, Lisp without parentheses?

@@stefanalecu9532 I don't know LISP enough to answer.

lol i just saw it

Not surprising, given the amount of penetration in this video. 🙃

same here, i'm trying to understand FP.

This paper from 1998 is an extremely nice introduction to lambda calculus www.cse.chalmers.se/research/group/logic/TypesSS05/Extra/geuvers.pdf

@@shubham.1172 Thanks

Same. It was very hard understanding functional programming a few weeks ago, before I started learning haskell. Now it feels really nice, this guy knows what he's doing.

fsharpforfunandprofit.com/posts/understanding-parser-combinators/ might be more approachable if you know or planning to learn F#

Для парсинга есть библиотека parsec. Это почти тоже самое,что он показал в видео.

JS dev here. I have no idea what I am watching.

Understandable, is probably the weirdest of them all. I think the problem is that it does way too many things: 1. It merges the Applicatives. 2. It applies the function of the right applicative to the value of the left applicative. It's really unintuitive what would you use such combination of actions for. Use case example at 41:30 is probably the best thing I could come up with. Sorry if I could not explain it better. I also initially didn't understand why would you need , but over time after working with Maybe-s a lot I eventually sort of realized what it's meant for.

Pure functions perform calculations. But sometimes you want to have not only pure calculations but side effects as well. Functors, applicative functors, and monads are exactly about it: about performing pure calculations AND/OR side effects. Let's take for example Double. Pure functions should be deterministic, it means they have to be defined for all possible operations with Doubles. But what if you divide a Double by zero? Dividing by zero is not defined, and the result of it is out of the set of Doubles. Thus, with Maybe Double you perform EITHER pure calculations by getting (Just result) OR perform a side effect (in our case it is Nothing). The Parser from the video is an example of performing pure calculations AND (instead of OR which we have seen with Maybe Double in the example above) side effects. When we parse the string we get the result of the pure calculation (the second element of the tuple) AND a side effect (the rest of the string as the tuple's first element). Now it is easy to grasp the notion of the () operator (it calls "apply"). You have two entities, and each of them performs pure calculation AND a side effect. When you "apply" the first of it to the second with the help of () operator, you need to perform pure calculations with both second values of tuples AND sequentially perform 2 side effects (to return the rest of the string from the first parser and to return the rest of the rest of the string from the second parser). So you are parsing the input string with the first parser (and get a tuple (the_rest_of_the_string, pure_function)), and then parse the_rest_of_the_string with the second parser (and get a tuple (the_rest_of_the_rest_of_the_string, pure_function_applied_to_value)). Hope it will help you to understand.

And later in the video, you will encounter 2 more operators from Applicative: (). The first operator () ignores the value of the first parser and takes the value of the second parser but performs side effects of both parsers as well.

I get it now... Thanks!

The way I kinda wrapped my mind around it is this: Imagine this: let a = (5+) let b = 5 In Haskell, everything is a function, and a and b can easily be combined with the expression a b. >a b 10 But not everything is a nice pure function. Sometimes you have Applicatives, like Maybe. Consider this: let a = Just (5+) let b = Just 5 You can no longer just do (a b) to get 10. Since Maybe is Applicative, however, we know that we can turn "inside out" the contents and evaluate the function of one with respect to the value of another. >a b Just 10 The result is an Applicative as well, an assertion that has been unadulterated by our . I've almost certainly oversimplified it but I hope the explanation makes it clearer.

I think he wanted to show how it works under the hood

I guess it's a personal preference. I personally like the Applicative style better because the set of resulting parsers sort of resembles BNF in structure :D

You could use the language extension ApplicativeDo

Ah, I see in the GitHub repo that at some point you did kinda the same.

I was thinking (const True) stringP "true" because I didn't know about

Lol I was thinking the same thing and glad someone 4 years ago thought the same