do you know if maybe someone has rewritten the Zig example more idiomatically and succinctly? I'd love to see that.

Yeah, figuring out all the fun and funky things one can do with fold is half the fun of functional programming.

Thanks for pointing this out! Sadly, I don't think the Elixir implementation was the only one that was more verbose than necessary...

@@codetothemoon you might wanna redo this video then

@@zzzyyyxxx A followup rather than a redo would be of interest.

At least there was only one list enumeration in the elixir program. 😅 I’m sure other language experts are picking apart the other examples too. Either way it was fun to look at elixir code keep it up @Code to the Moon

Nice! Crystal is definitely one of the languages I was most impressed with when preparing this video.

yeah man been using crystal for quite some time and kinda gotten addicted... wait do you mean the programming language? /s

*Haskell

I agree, Vale looks super interesting! I was actually going to include it in the video, but I ran into a roadblock trying to read stdin to a String. I asked the lead about it on the Vale Discord, and they said it was something they were going to implement. So I figured I'd do a separate video about it - Vale is actually the language I'm hinting about at the very end

thanks for pointing this out! several of the solutions in this video are suboptimal, Julia seems to be one of the more egregious cases of that

@@codetothemoon I would also use Vector{

Ahh .. more language syntax that I have no idea what it does.

Ahh I didn't know F# had it too, I do hope it becomes more commonly implemented in new languages

♥|> F#

@@codetothemoon believe it or not but c++ 20 has it 😂

@@codetothemoon If I am not mistaking the functional programming language OCaml introduced that pipe operator. That was both Elixir and F# have drawn inspiration from. There are very good video series by a professor from the UK on youtube, the series has more than 100 videos and he shows you have to try the code online on the browser, no need to install anything. I got to OCaml when I after falling in loved with F# I was disappointed to find out that F# is roughly totally based on OCml, they look the same when it comes to the functional style, since F# also accept the OOP approach with imperative style. So now I am sticking to OCaml, since it is where F# came partially from. OCml, Haskell, Erlang the Common Lisp are quite a challenge, but these are really interesting programming languages. I am very surprised how many implementation are so concise in these 4 languages.

@@emoutraspalavras-marloncou4459 as someone who is also learning some OCaml and F#, would still say F# is more 'usable' as it can use/be used alongside C# projects, with C# itself bing quite popular; While OCaml is quite niche and honestly just less practical, with it only recently being able to do async and multi-thread without hacks

I was impressed by nim as well! Seems like it has a bright future

check "sugar" module!

@@agustinpizarro That module always blow my mind!!! 🤯

Meta programming is above my mental ability. I had some excitement for Nim last year, nothing came off it.

wow, nice! thanks for pointing this out!

With interact: main = interact $ unlines . map (show . sum . map read . words) . lines This is longer but I think more understandable.

@@codetothemoon the >> and >>= are Haskell's monad binding operators, and from my research it is quite similar to elixir's pipe as well

You can also just use forever instead of the explicit recursion.

@@Axman6 I want to second this. Using "forever $ do …" (or "forever do …" with {-# LANGUAGE BlockArguments #-}) reads very much just as well as "loop { … }" in Rust.

Thanks, I really enjoyed making it. I got Rust for Rustaceans recently as well, it's a fantastic book! I didn't realize Reaper supported Lua as well, seems like everyone is fixated on Neovim's support for it these days

Reaper is a great DAW, love it!

lua 'end syntax' and 1 based indexing is annoying to me

Lau is a scripting language... I didn't mind that. It's another level of abstraction. There is a major difference between scripting and programming - one needs a run time, the other doesn't. I think Lua is great as a tool, if your Hong to learn lua, then python, which can be semi-compiled. I find that a language that has support everywhere is easier for me. Rust on everything for example, Python is everywhere... of course the C's are everything, but they are a pain.

oh nice I didn't realize this! I'm learning a ton hearing from practitioners of all of these languages - thanks for pointing these things out!

Edit: I just realized someone gave this comment before me. ​​@@codetothemoonIn addition you could do: ``` ints = parse.(Int, splits) sum(ints) ``` Instead of having sum_fn at all. Here the . (dot) is shorthand for broadcast, so it just creates a vector of Integers from the get-go.

Also wanted to add that Julia has the pipe operator too, not only Elixir

Yes, I came here to say that, plus it supports the pipe operator too. I actually tend to write my code using a lot of `Base.Iterators.map` and `Base.Iterators.filter` so that they'll be lazy in their execution lol. ```julia parse_Int(x) = parse(Int, x) function main() # Rather than the infinite loop, you can use eachline() to create an iterator of the lines from stdin for line in eachline() line |> split .|> # Broadcast pipe, applies the subsequent function to the elements of the input, rather than the whole input parse_Int |> sum |> println end end main() ```

Thanks, I'm learning a ton from experts such as yourself in each of these languages. I believe there is representation for every single one in the comments, which is really cool

There is no such thing. If something is good in programming, it won't stay a secret.

So young but beautiful lang with lua-like syntax and LuaJIT speed(and even faster). Who knows maybe if Julia may be older NeoVim devs use it instead of LuaJIT...

It does seem under-appreciated!

I have such a love-hate relationship with julia. But it is becoming my go-to language, so it is doing something right 😅

I’ve chosen Julia to be my general purpose / ML / DS language for the near future. Hope to work with both RUST and JULIA in health informatics. Let’s see what the future will show.

Thanks, I've put Haxe on my "to check out" list - which is swelling in size quite rapidly (I see that as a good thing)!

nice!! yeah I was really impressed with nim. Somebody mentioned in the comments that they were working on a borrow checking option - now that would be a game changer

thanks for pointing this out! the distinction is subtle but probably important to be aware of

I should have qualified that statement a bit more - all of its mechanisms for memory safety involve some kind of runtime overhead - ie reference counting or garbage collection

ahh thanks for pointing this out, that makes more sense!

And Lua too

nice! I agree the comments are really insightful - I think I've heard from at least one expert in each of the languages covered in the video which is amazing. Also many point out tech that I hadn't heard of before, this one is a good example. I've put Pharo on my "to look into" list!

Thanks, part of me was worried folks would say something to the effect of "we've already tried all of these", glad to hear that's not the case!

Nice, thanks for pointing this out!

nice, yeah I was really impressed with Crystal. Definitely worth a look imo!

And F# took that from OCaml, F# is basically "Microsoft's OCaml" or ".Net OCaml"

Interesting insights. I used to use Elixir quite a lot and really liked it, although it's not the most performant language for compute-heavy work. We used it to replace a Python-based image-processing system in my old job and it not only produced a MUCH more efficient system, but we ended up with far less code to the same job better and with fewer bugs (immutability by default helped here too). I've used Haskell and Nim for fun, and did pretty much all of the 2020 and 2021 Advent of Code challenges in Haskell, and all the 2022 challenges in Nim (and a few in Crystal too). I'd have to disagree with your second point and say that Nim rarely got in my way or crashed, except when I tried to do some invalid casting of bytes to UTF-8, which did produce an unpleasant segfault. Apart from that it's been great. That said, I wasn't using it without a GC, and relied upon the newish "orc" system which is quite frugal. I really enjoyed working with Haskell too, although the purity of the type system started to get kinda heavy when I wanted to use dynamic programming and other mutation-heavy coding styles. Using mutable arrays with the ST monad was okay but occasionally confusing and very difficult to debug (you can't just throw in a print statement anywhere), and there doesn't seem to be a mutable hashmap type in the stdlib, so I had to do weird things like manually mapping keys into an integer space and using a vector/array instead.

In this documentation I see "ORC" referred to as a "full blown garbage collector" nim-lang.org/blog/2020/10/15/introduction-to-arc-orc-in-nim.html

Reference counting IS garbage collection (even if very lightweight), that's what the "RC" in ORC stands for. Cycle collection is also garbage collection, which is what the "O" in ORC represents. Not to say that there is anything wrong with it, Nim is wonderful and so is ORC. ORC is great because it allows you to prototype your code very easily without being forced to think about memory, you can always come back and optimize later (which IMO is the optimal workflow), you can still use memory pools or whatever memory management scheme you would want to use in Rust, you are just not required to worry about such things from the get-go and just leave it to the GC until you require better performance.

you're welcome, thanks for watching - brevity is one of my core tenets 🏎️

I won't even lie to you, I didn't know Swift worked on anything but Apple products until this comment. Guess it's in the same boat as C# now in the sense that it was originally for a proprietary system but expanded compatibility. Interesting.

@@v01d_r34l1ty Yeah, the connection to Apple makes the language look bad; actual Swift code looks completely different from the decades old object oriented apis, but that's what most people will see when they look up Swift on google or UKposts. It also looks really high level, so at first I assumed it must be slower than Rust; there's no semicolons after all 🙂

that's one i hadn't heard of, thanks for putting it on my radar!

Crystal does seem like a great language - thanks for watching!

ahh thanks for pointing this out!

Thanks for the feedback, maybe in the next one!

it's all here! will gladly accept PRs. github.com/Me163/youtube/tree/main/RustVsSevenLanguages

sum . map (read @Integer) The whole app can just be: main = forever (print @Integer . sum . map read . words =

yeah it sure is - i had to use ocaml for a course in university, and I remember being really frustrated with it. I was too shortsighted to appreciate the beautify of it back then, but I sure do now

I'm definitely not a nim expert - but my understanding was that you can opt-in to reference counting or garbage collection if you want to guarantee memory safety, but if you opt out of that, you incur the same memory management risks that you would have with C/C++. Somebody jump in here if this is wrong!

@@codetothemoon It is not "safe" as Rust, but ARC/ORC are deterministic memory handling as C++ but with some memory handling done automatically for you, like you'll do with shared_ptr in C++

interesting, why do you think that is?

@@codetothemoon Great question. So off the top, coming in hot. - Simple syntax: Zig has a simple syntax comparable to Go, maybe even easier due to it's clever error handling and that it launched with generics. - No garbabe collector: The issues with Nim as much of the standard library is already relient on the GC. - Easier to code in the Rust, my god, Rust is amazing but imagine coupling the safety of Rust with a Golang Syntax = Zig. - Complete compatibity with C libs and C++ - The cross compilation is super fast and is being used by other languages to hit those targets, other languages are leveraging Zig already for compliation work. - C speed, and faster than C with better compiler. Basically if your a C developer you're being advised to use Zig to compile your C code. Zig will replace C, that's without a doubt. I even speculate it replacing Golang down the line as the memory management is easy. So why comprimise on speed when you don't need to. Zig has about two years of catch up planned to reach 1.0 and for editor tooling to evolve.

@@seanknowles9985 does zig have a 100% memory safe subset? That's required by the US NSA guidelines.

@@nicktreleaven4119 good question! I'll throw it to the development team :)

oh nice that one is really concise too! I'm still wrapping my head around the Lisps, might have more coverage of them once I find my footing

I was indeed pretty impressed with Julia. With Mojo coming along, it'll be interesting to see how the landscape evolves in the coming years

Thanks, I actually mic'd up the keyboard for this one thinking folks might like it

@@codetothemoon it adds a little more "depth" to the typing animation, and overall the sound you got is just nice to the ear

thanks for pointing this out, this is much cleaner! I've been learning a ton from the reactions of the experts in each language showcased in this video.

actually already did! if you want the original version it's here: ukposts.info/have/v-deo/oqJieXiYg6Gbx5c.html BUT if you want the version with Primeagen commentary (recommended) you can find that here: ukposts.info/have/v-deo/omRofKFsqHtqoqc.html

ahh thanks for pointing this out, that makes more sense!

thank you!

Wow yes, thanks for pointing this out! Sadly I don't think it's the only version of this program that I implemented sub optimally...

Actually this one was on my radar, but for some reason I never really thought of it as the reverse of the pipe operator!

I'm not doing anything special, I just uncommented the relevant programming languages in init.el and switched to the monokai-pro theme. The only real config I had to add was some stuff to get Zig working, since I don't think DOOM supports it out of the box.

thanks, didn't know about this!

Good idea, though remember that interact want (String -> String) so no print in your function. You also don't need to recurse, if you want to do "f" line by line, you can always use `interact (unlines . map f . lines)`. Here, with TypeApplications to specify the Read type elegantly, you can do this : interact $ unlines . map (show . sum . map (read @Integer) . words) . lines

@@chaddaifouche536 amazing. love the type application! thanks for the correction too, I didn't think interact automatically recursed

thank you so much for your support!!!

I think it's monolisa, could be wrong

this "while" line is like the most dense matter in the universe :D

@@adicide9070 oh I thought it was just perl 😀

Just OBS for the screen recording!

heard a little bit about APL, definately one I'd love to look into

yeah i've been itching to give Gleam a spin, it looks really nice!

I was really impressed by it too and was also surprised by its lack of popularity. i hope to be able to cover it more!

stop spreading this misinformation, the pipe operator has been around long before f#

It's even easier than you think, but kudos for learning. Try this +/⎕ ⎕ (quad) by itself means read a line from standard input and evaluate as an APL expression. So if you type in a bunch of integers it'll turn it into an integer array. Then obviously +/ just sums it up and outputs.

oh nice I'd like to check it out! definitely heard F# mentioned in the context of underrated/overlooked languages....

As of today, one language should be very special to make me ever consider using it. F# is awesome!

@@codetothemoon Yes, this is my takeaway from learning and using F#. It is a very underrated language and popular languages are not always the best ones.

thanks for pointing this out!

Thanks for pointing these languages out, I've heard Odin mentioned a few times. Would be happy to walk you through the Rust code if you like!

@@codetothemoon Oh, that's great. I would like to use this opportunity to ask some questions. 1. You declared the buffer as mutable. So the compiler can understands that buffer is mutable. But why we need to use &mut with buffer in next line ? Didn't the compiler already understand that? 2. What does unwrap() does ?

@@kcvinu 1. Rust is sometimes quite explicit not because the compiler couldn't understand it but to have it explicitly mentioned in the code for the human reader. Something with references. In C++ you define whether something is passed by reference in the function header and you don't see it in the call at all. So it's more like: This is important information for the reader of the calling code / code that uses a function, so it has to be given explicitly. Rust is not very explicit in other cases (type inference is heavily used) Edit: That's not a Rust invention, if I remember correctly C# is also already more explicit than C/C++ with these things) Edit2: You could also immutably pass a mutable String to a function. So the let mut buffer says it can be mutated (in general) and the read_line(&mut buffer) says it can mutated within read_line. 2. There are two things, which are very commonly used in Rust: Option and Result. Option is used when you expect a value, but it could also be that there is no value - the "no-value" is called None. It's basically the replacement for Null. Result is you expect a result (from a function) but it could be that you get an error. It's Rust's error handling (instead of try..catch or the different variants of error return values in C). What both have in common is, that you Rust forces you to deal with the "extra" cases (None, Error). The "dirty" way is using unwrap(), which says: I know what I'm doing, there is a value inside this Option/Result, just unwrap it and give it to me. If you're wrong and there is a None or an Error the program will crash.

I'd have to agree!

Zig is a simple language as c is. So it can be more verbose but the learning is easier and the code is more predictable.

c# is just wrong, pointless overuse of capital letters and braces.

@@terryriley6410 cs is the other name that it has, but still has 2 characters :(

I agree that the borrow checker takes the cake for the most recent language feature that is truly innovative

ohh I didn't know about this, I'll give it a spin - but yes I agree |> is much more aesthetically pleasing 🙃

Isn't V nice? It's so simple, but it's so fully featured (except for async). I love the UI and CLI modules.

V has a long history of overpromising and underdelivering. Like promising Rust-like automatic memory management without lifetime annotations and GC and ending up with just leaking memory and using a conservative GC. V is for vapourware.

Would you be interested in that? I'd love to make one, I've been unsure about whether folks find editor related videos valuable - especially because I believe most folks watching are using VSCode. Also I'm still on the fence on whether to move forward with Doom or Neovim...

@@codetothemoon I'm personally a NeoVim user but I'm would like to see what deal on the "other side". So I'm would very like to watch video about that

thank you!

what makes it fun? I got a bit of exposure to it while making this video, but I still don't feel like I have the whole picture...

After seeing Haskell's `interact` mentioned in the comments, I figured out how to make the Idris version even sleeker: import System.REPL import Data.String main : IO () main = repl " " (cast . sum . map cast . words)