These terms got mentioned in my university course. Quick googling pointed me to some university papers, but I am looking for a simple explanation.
What is Banana split and fusion in functional programming?
functional programming;haskell
So this is actually a referenced to a paper by Meijer and a few others called Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire, the basic idea is that we can take any recursive data type, like say data List = Cons Int List | Niland we can factor out the recursion into a type variable data ListF a = Cons Int a | Nilthe reason why I appended that F is because this is now a functor! It also allows us to mimic lists, but with a twist: to build lists we have to nest the list typetype ThreeList = ListF (ListF (ListF Void)))To recover our original list we need to keep nesting this infinitely. That will give us a type ListFF where  ListF ListFF == ListFFTo do this define a fixed point type  data Fix f = Fix {unfix :: f (Fix f)}  type ListFF = Fix ListFAs an exercise, you should verify this satisfies our above equation.Now we can finally define what bananas (catamorphisms) are!  type ListAlg a = ListF a -> aListAlgs are the type of list algebras, and we can define a particular function  cata :: ListAlg a -> ListFF -> a  cata f = f . fmap (cata f) . unfixFurther more  cata :: ListAlg a -> ListFF -> a  cata :: (Either () (Int, a) -> a) -> ListFF -> a  cata :: (() -> a) -> ((Int, a) -> a) -> ListFF -> a  cata :: a -> (Int -> a -> a) -> ListFF -> a  cata :: (Int -> a -> a) -> a -> [Int] -> aLook familiar? cata is precisely the same as right folds!What's really interesting is that we can do this over more than just lists, any type which is defined with this fixed point of a functor has a cata and to accomdate them all we just have to relax the type signature  cata :: (f a -> a) -> Fix f -> aThis is actually inspired from a piece of category theory which I wrote about, but this is the meat of the Haskell side.