fold

When I build a list using foldLeft I often get annoyed at having to explicitly type the injected parameter and wish I could just use `Nil' instead - here's a contrived example: scala> List(1,2,3).foldLeft(List[Int]())((x,y) => y :: x) res17: List[Int] = List(3, 2, 1) scala> List(1,2,3).foldLeft(Nil)((x, y) => y :: x) <console>:10: error: type mismatch; found : List[Int] required: scala.collection.immutable.Nil.type List(1,2,3).foldLeft(Nil)((x,y) => y :: x) This isn't so bad with a List[Int] but as soon as you start using lists of your own classes, which are almost certainly going to have

I have a set of sequential nodes that must be enclosed into a new element. Example: <root> <c>cccc</c> <a gr="g1">aaaa</a> <b gr="g1">1111</b> <a gr="g2">bbbb</a> <b gr="g2">2222</b> </root> that must be enclosed by fold tags, resulting (after XSLT) in: <root> <c>cccc</c> <fold><a gr="g1">aaaa</a> <b gr="g1">1111</b></fold> <fold><a gr="g2">bbbb</a> <b gr="g2">2222</b></fold> </root> So, I have a "label for grouping" ( @gr ) but not imagine how to produce correct fold tags. I am trying to use the clues of this question , or this other one ... But I have a "label for grouping", so I understand

I am trying to use compact fold expression without success. For instance here is a working C++17 code template <bool... B> struct Fold_And : std::integral_constant<bool, (B && ...)> { }; template <bool... B> constexpr auto Fold_And_v = Fold_And<B...>::value; template <typename V, typename... Vs> std::enable_if_t< Fold_And_v<std::is_floating_point_v<V>, std::is_floating_point_v<Vs>...> > foo(const V& v, const Vs&...) { } I want to translate it into a more compact form (not using the intermediate Fold_And ) template <typename V, typename... Vs> std::enable_if_t<std::is_floating_point_v<V> && ...

I'm writing a function that does some searching in a sequence of arbitrary symbols. I'd like to make it generic enough so that it works on lists, Foldable s as well on ByteString s and Text s. Generalizing it to Foldable is simple. But how to include ByteString s and Text s? Sure I could convert ByteString into a list and then call my function, but I'd lose all the advantages ByteString s. To have a concrete example let's say we want to make a histogram function: import Control.Monad.State import qualified Data.Foldable as F import Data.Map.Strict (Map) import qualified Data.Map.Strict as Map

The following blog article shows how in F# foldBack can be made tail recursive using continuation passing style. In Scala this would mean that: def foldBack[T,U](l: List[T], acc: U)(f: (T, U) => U): U = { l match { case x :: xs => f(x, foldBack(xs, acc)(f)) case Nil => acc } } can be made tail recursive by doing this: def foldCont[T,U](list: List[T], acc: U)(f: (T, U) => U): U = { @annotation.tailrec def loop(l: List[T], k: (U) => U): U = { l match { case x :: xs => loop(xs, (racc => k(f(x, racc)))) case Nil => k(acc) } } loop(list, u => u) } Unfortunately, I still get a stack overflow for