User defined function, recursion and passing self along

Hmm, can you give an example of the code as you want it to look and what error you get and on what line so we can see what is happening?

This is a known problem in functional languages. How to make a recursive anonymous function?
Even something as simple as factorial is hard to write:

fac = fn(0) -> 1
            (n) -> fac.(n-1) * n end
** (CompileError) iex:2: undefined function fac/1

There are topics abou it on Erlang mailing list and there is this in particular:

and it shows a trick to get around that limitation:

fac = fn(0, _f) -> 1
            (n, f) -> f.(n-1) * n end
factorial = fn(n) -> fac.(n, fac) end
factorial.(5)

The good news is this workaround is easy. The bad news is that you would have to teach it to every single user of your library (or just use named functions).

Thanks for sharing this great trick! On the one hand, wished I could have come up with it myself (as I did something like it) but at the same time it’s genius. Had to adapt it a bit as Map.merge/3 expects a function with arity 3.

If anyone is interested, this is the commit.

Thanks a ton once again!

That style is called the Y-Combinator. There are many kinds of combinators, should look them up.

Thanks! Definitely still need to brush up my FP (only dabbled in Clojure, LISP and Scala a bit before) which is why Elixir is so great to pick up and learn as I can expand my mind on FP, distributed systems/OTP and many other great concepts.

To my shame, before I mistook “Y combinator” for the general “we derive the whole of computation from just functions” which I think is rather called lambda calculus

A bit OT, but if you have some good resource to share (book or web) for learning about “ALL THE COMBINATORS” I’d appreciate it. Maybe I should dig out Land of LISP again…

No need for lisp, just normal functional stuff.

I usually just point people to the wikipedia article, short, to the point for each combinator: Fixed-point combinator - Wikipedia

For Elixir there are libraries that simplify the combinators as well, such as quark, where the Y-Combinator is named fix for being a fixed-point combinator, but it shows a lot of other non-fixed point combinators as well (that same author makes a lot of awesome libraries like that, especially for functional design, click their name on the lower-right of that page too, especially as a lot of their libs are designed to be used together).

Here’s a great resource to learn about combinators in general, if Ruby as a sample language works for you: Kestrels, Quirky Birds, and Hopeless Egocentricity

That is fascinating. Ruby uses combinators everywhere.

Also, wtf?!?

[1,2,3,3,4,5].uniq!
  => [1,2,3,4,5]

[1,2,3,4,5].uniq!
  => nil

Uh… wtf?! A prime example of why I like statically typed languages, this oddness would be encoded in the type instead of being, just… wtf…?

I’m not sure what static typing has to do with this situation. I think of that wtf as a mutability issue. If you use the non-bang version of uniq you’ll find the result less confusing. I’ve found myself avoiding bang methods in Ruby more and more as my experience grows.

irb(main):001:0> a = [1,2,3,3,4,5]
=> [1, 2, 3, 3, 4, 5]
irb(main):002:0> b = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):003:0> a.uniq
=> [1, 2, 3, 4, 5]
irb(main):004:0> b.uniq
=> [1, 2, 3, 4, 5]
irb(main):005:0> a.uniq!
=> [1, 2, 3, 4, 5]
irb(main):006:0> b.uniq!
=> nil
irb(main):007:0> a
=> [1, 2, 3, 4, 5]
irb(main):008:0> b
=> [1, 2, 3, 4, 5]
irb(main):009:0>

uniq! modifies the array in place and returns the modified version or else it’s already unique and it returns nil to indicate that. It’s a horribly confusing method. uniq just returns a new array with unique elements.

I noticed the non-bang was consistent yep, but mutating methods or not, returning a value should be fairly consistent, after all ‘why’ did it return nil in the case it did not make changes, yet it returned self when it did, why not always return self so you can chain?

That really really badly should have had a new name indeed, that seems so counter-intuitive and internally inconsistent compared to the surrounding methods (Principle of Least Surprise is violated! ). If anything it should have returned true or false, not self or nil. o.O