y-combinator

I'm interested in actual examples of using fixed point combinators (such as the y-combinator in C++. Have you ever used a fixed point combinator with egg or bind in real live code? I found this example in egg a little dense: void egg_example() { using bll::_1; using bll::_2; int r = fix2( bll::ret<int>( // \(f,a) -> a == 0 ? 1 : a * f(a-1) bll::if_then_else_return( _2 == 0, 1, _2 * lazy(_1)(_2 - 1) ) ) ) (5); BOOST_CHECK(r == 5*4*3*2*1); } Can you explain how this all works? Is there a nice simple example perhaps using bind with perhaps fewer dependancies than this one? Ted Here is the same

This is the usual definition of the fixed-point combinator in Haskell: fix :: (a -> a) -> a fix f = let x = f x in x On https://wiki.haskell.org/Prime_numbers , they define a different fixed-point combinator: _Y :: (t -> t) -> t _Y g = g (_Y g) -- multistage, non-sharing, g (g (g (g ...))) -- g (let x = g x in x) -- two g stages, sharing _Y is a non-sharing fixpoint combinator, here arranging for a recursive "telescoping" multistage primes production (a tower of producers). What exactly does this mean? What is "sharing" vs. "non-sharing" in that context? How does _Y differ from fix ? "Sharing"

My brain seems to be in masochistic mode, so after being drowned in this , this and this , it wanted to mess around with some DIY in C#. I came up with the following, which I don't think is the Y-combinator, but it does seem to manage to make a non-recursive function recursive, without referring to itself: Func<Func<dynamic, dynamic>, Func<dynamic, dynamic>> Y = x => x(x); So given these: Func<dynamic, Func<dynamic, dynamic>> fact = self => n => n == 0 ? 1 : n * self(self)(n - 1); Func<dynamic, Func<dynamic, dynamic>> fib = self => n => n < 2 ? n : self(self)(n-1) + self(self)(n-2); We can

In almost all examples, a y-combinator in ML-type languages is written like this: let rec y f x = f (y f) x let factorial = y (fun f -> function 0 -> 1 | n -> n * f(n - 1)) This works as expected, but it feels like cheating to define the y-combinator using let rec ... . I want to define this combinator without using recursion, using the standard definition: Y = λf·(λx·f (x x)) (λx·f (x x)) A direct translation is as follows: let y = fun f -> (fun x -> f (x x)) (fun x -> f (x x));; However, F# complains that it can't figure out the types: let y = fun f -> (fun x -> f (x x)) (fun x -> f (x x));;

Is it possible to write the Y Combinator in Haskell? It seems like it would have an infinitely recursive type. Y :: f -> b -> c where f :: (f -> b -> c) or something. Even a simple slightly factored factorial factMaker _ 0 = 1 factMaker fn n = n * ((fn fn) (n -1) {- to be called as (factMaker factMaker) 5 -} fails with "Occurs check: cannot construct the infinite type: t = t -> t2 -> t1" (The Y combinator looks like this (define Y (lambda (X) ((lambda (procedure) (X (lambda (arg) ((procedure procedure) arg)))) (lambda (procedure) (X (lambda (arg) ((procedure procedure) arg))))))) in scheme) Or