LIVE ON TWITCH: / theprimeagen Check out Teej!: / @teej_dv / teej_dv Get in on Discord: / discord Get in on Twitter: / theprimeagen Got Something For Me to Read or Watch??: / theprimeagenreact
A subtle thing that wasn't quite clear is that `in` is continuing the expression in a child scope. Those functions are actually just giant expressions , which themselves have child expressions. Functional code has generally more of a tree structure (as opposed to a linear series of operations) and you mostly don't need the opening/closing delimiters.
Indeed! Saying "let statement" is a bit misleading as there are no statements in functional programming languages (Haskell atleast, a bit unsure about OCaml)
All programs are trees. Imperative languages are just replace “let” with “var” and “in” with “;” so you as a programmer had impression it is not a tree/list.
one thing you algol-ish people should know about the functional side of the programming spectrum, when SML made its syntax which is the syntax that OCAML took from, they did it as the anti-lisp syntax, lisp was "the researcher's language" and some researchers got fed up with the parenthesis so they made SML the with minimal punctuation. As the legend says Lisp was supposed to have 2 syntaxes, Symbolic-Expressions & Meta-Expressions, but they only implemented Symbolic-Expressions, then people who wanted to get out of the parenthesis decided to "Let's make a language that is the Meta-Expressions that Lisp should've had" and they name it MetaLanguage, or ML for short.
Not knowing OCaml, but knowing Haskell, I think that what confuses you about “let … in” is the function definition. Things doesn’t necessarily happen in the order it’s written. A function is defined as exactly one expression (such as “function a = a + 5”). This is pretty useless, though, so you can define symbols for that expression as such: “countSpaces text = let all_spaces = filter isSpace text in Text.len all_spaces”. The expression here is “Text.len all_spaces” and the symbol “all_spaces” is valid for the expression after “in”.
It's basically Haskell, but without function overloading. You still have the ability to derive "typeclasses" with a ppx, but instead of deriving an instance of show or eq for example it will autogenerate functions like show_foo, show_bar and so on. So you end up just writing very concrete and readable application code as the path of least resistance instead of using abstractions by default, while still being able to write generic code with module functors if you actually need to write a generic library. The other nice thing about it is that you can add print statements anywhere and execution order is not UB, unlike Haskell where code is easy to test but fundamentally undebuggable. Laziness is opt-in instead of opt-out Of course, the flipside is that the community is smaller than the Haskell one, and not even in the same ballpark as something like Rust or Go. And in some cases you do in fact miss typeclasses, especially for mathy code.
I wish they would have brought up the ReasonML homepage because the first example there was a case statement with brackets :D I found that it's much easier to transition from C style languages to Reason, learn how the ML system works, and then once comfortable learn OCaml and it's only a small jump to get there.
I agree with that, learn semantics in a friendly syntax goes a long way. I went from Ruby to Elixir and the syntax was similar but the semantics are completely different. I picked up Standard ML afterwards which is pretty similar to OCaml. I just had to wrap my head around the type semantics. That said, I re
Clojurescript -> TypeScript... TypeScript -> Rescript... OCaml -> Rust... C# -> F#... we need ADTs to be the norm along with pattern matching and maybe we could stick with our programming langs for longer. 😂
Javascript and all these algolish languages copied the "let" wrong. Let has always being a syntactic block, never a statement like in lisp (let ((var value)...) _expressions...) in the MLs let _var = values_ in _expressions_
T.o be honest, I R.eally like that Y.ou have decided to E.xperience at L.east a fraction of what -true- FP has to offer. M.ay you eventually see the light of lambda and pi!
A subtle thing that wasn't quite clear is that `in` is continuing the expression in a child scope. Those functions are actually just giant expressions , which themselves have child expressions. Functional code has generally more of a tree structure (as opposed to a linear series of operations) and you mostly don't need the opening/closing delimiters.
Indeed! Saying "let statement" is a bit misleading as there are no statements in functional programming languages (Haskell atleast, a bit unsure about OCaml)
All programs are trees. Imperative languages are just replace “let” with “var” and “in” with “;” so you as a programmer had impression it is not a tree/list.
one thing you algol-ish people should know about the functional side of the programming spectrum, when SML made its syntax which is the syntax that OCAML took from, they did it as the anti-lisp syntax, lisp was "the researcher's language" and some researchers got fed up with the parenthesis so they made SML the with minimal punctuation. As the legend says Lisp was supposed to have 2 syntaxes, Symbolic-Expressions & Meta-Expressions, but they only implemented Symbolic-Expressions, then people who wanted to get out of the parenthesis decided to "Let's make a language that is the Meta-Expressions that Lisp should've had" and they name it MetaLanguage, or ML for short.
Not knowing OCaml, but knowing Haskell, I think that what confuses you about “let … in” is the function definition. Things doesn’t necessarily happen in the order it’s written. A function is defined as exactly one expression (such as “function a = a + 5”). This is pretty useless, though, so you can define symbols for that expression as such: “countSpaces text = let all_spaces = filter isSpace text in Text.len all_spaces”. The expression here is “Text.len all_spaces” and the symbol “all_spaces” is valid for the expression after “in”.
I love Haskell and this video makes me wanna learn OCaml so much, it looks so much like Haskell but with its own quirks, I love it!! So pretty!!
It's basically Haskell, but without function overloading. You still have the ability to derive "typeclasses" with a ppx, but instead of deriving an instance of show or eq for example it will autogenerate functions like show_foo, show_bar and so on. So you end up just writing very concrete and readable application code as the path of least resistance instead of using abstractions by default, while still being able to write generic code with module functors if you actually need to write a generic library.
The other nice thing about it is that you can add print statements anywhere and execution order is not UB, unlike Haskell where code is easy to test but fundamentally undebuggable. Laziness is opt-in instead of opt-out
Of course, the flipside is that the community is smaller than the Haskell one, and not even in the same ballpark as something like Rust or Go. And in some cases you do in fact miss typeclasses, especially for mathy code.
I understood every other language, this was just over my fkin head
I really like the synthax but in the same time I don't understand anything
that's functional for ya
Because every other language is the same fkin language
it's not that hard, just some syntax quirks but the concepts are pretty clear i think
It way less Cognitive load write code this way.
Such a beautiful language !
Haskell--
I wish they would have brought up the ReasonML homepage because the first example there was a case statement with brackets :D I found that it's much easier to transition from C style languages to Reason, learn how the ML system works, and then once comfortable learn OCaml and it's only a small jump to get there.
I agree with that, learn semantics in a friendly syntax goes a long way. I went from Ruby to Elixir and the syntax was similar but the semantics are completely different. I picked up Standard ML afterwards which is pretty similar to OCaml. I just had to wrap my head around the type semantics.
That said, I re
Clojurescript -> TypeScript... TypeScript -> Rescript... OCaml -> Rust... C# -> F#... we need ADTs to be the norm along with pattern matching and maybe we could stick with our programming langs for longer. 😂
Pretty good F# code
Hell yeah fsharp. They're likely getting sick of me gushing about it. Lol.
For me F# is one of the best Functional languages for sure.
Guys, what plugin is used to display nesting hierarchy at the top of the screen?
nvim-treesitter/nvim-treesitter-context
Given that Prime knows Rust already, I'm surprised he didn't get the Ocaml constructs (I didn't come from Ocaml either)
OCaml and F# ❤
I'm wondering which of the two i should start learning, do you suggest more F# or OCaml?
if they used haskell it would be easier to understand the let bindings ;)
/s
OCaml > Rust
If your dealing with a lot of recursive data structures then it blows it away. If perf is critical then u gotta go rust ofc
use the best tool for you
#[derive(skill_issue)]
Describing OCaml as "Visually clear" is just ... insulting.
OCaml is the shit
Ocaml my caml!
Is this haskell but ugly?
OCaml is not lazy also.
Ugly Haskell with optional immutability
Haskell but usable
@TheVimeAgen this guy right here
Looks like it lol
Haskell mentioned
the more I look into functional programming, the more I realize it's even worse than oop
Ocaml is inspired from plsql devs !??
Javascript and all these algolish languages copied the "let" wrong. Let has always being a syntactic block, never a statement like in lisp
(let ((var value)...) _expressions...)
in the MLs
let _var = values_ in _expressions_
Do you have to be criminally insane to understand code like this? Or am I just stupid.
I'm late I'm learning Ocaml now and my brain is in this state where I can read the code but would never think to write this.
show and eq are like traits
T.o be honest, I
R.eally like that
Y.ou have decided to
E.xperience at
L.east a fraction of what -true- FP has to offer.
M.ay you eventually see the light of lambda and pi!
What you did there, I see it.
Might do an Idris2 one >:)