There&#39;s a difference if your function isn&#39;t associative (i.e. it matters which way you bracket expressions) so for example,  
`foldr (-) 0 [1..10] = -5` but `foldl (-) 0 [1..10] = -55`.  
This is because the former is equal to `1-(2-(3-(4-(5-(6-(7-(8-(9-(10 - 0)))))))))`, whereas the latter is `(((((((((0-1)-2)-3)-4)-5)-6)-7)-8)-9)-10`.


Whereas because `(+)` is associative (doesn&#39;t matter what order you add subexpressions),  
`foldr (+) 0 [1..10] = 55` and `foldl (+) 0 [1..10] = 55`. `(++)` is another associative operation because `xs ++ (ys ++ zs)` gives the same answer as `(xs ++ ys) ++ zs` (although the first one is faster - don&#39;t use `foldl (++)`).


Some functions only work one way:  
`foldr (:) :: [a] -&gt; [a] -&gt; [a]` but `foldl (:)` is nonsense.

Have a look at Cale Gibbard&#39;s diagrams (from the [wikipedia article](http://en.wikipedia.org/wiki/Fold_(higher-order_function))); you can see `f` getting called with genuinely different pairs of data:  
![foldr][1]![foldl][2]

Another difference is that because it matches the structure of the list, `foldr` is often more efficient for lazy evaluation, so can be used with an infinite list as long as `f` is non-strict in its second argument (like `(:)` or `(++)`). `foldl` is only rarely the better choice. If you&#39;re using `foldl` it&#39;s usually worth using `foldl&#39;` because it&#39;s strict and stops you building up a long list of intermediate results. (More on this topic in the answers to [this question](https://stackoverflow.com/questions/3429634/foldl-is-tail-recursive-so-how-come-foldr-runs-faster-than-foldl).)


  [1]: http://i.stack.imgur.com/31GG4.png
  [2]: http://i.stack.imgur.com/C4APB.png

Assuming I have the following string array:

    string[] str = new string[] {&quot;max&quot;, &quot;min&quot;, &quot;avg&quot;, &quot;max&quot;, &quot;avg&quot;, &quot;min&quot;}

Is it possbile to use LINQ to get a list of indexes that match one string?

As an example, I would like to search for the string &quot;avg&quot; and get a list containing 

&gt;2, 4

meaning that &quot;avg&quot; can be found at str[2] and str[4].


LINQ to find array indexes of a value

Is there a way to exclude some modules from a big reactor build, similar to -pl ?

Here are a number of ways to do it persistently:

https://stackoverflow.com/questions/5539348/how-to-exclude-a-module-from-a-maven-reactor-build

I want to do it from shell, or at least without modifying the poms, which I am not allowed to change.

How do I exclude certain modules from a Maven build using the commandline

Is difference between `foldl` and `foldr` just the direction of looping? I thought there was a difference in what they did, not just in the direction?

Haskell - foldl and foldr?

<p>Is difference between <code>foldl</code> and <code>foldr</code> just the direction of looping? I thought there was a difference in what they did, not just in the direction?</p>


Reading through [this classic paper](http://www.google.com/search?q=functional+programming+with+bananas+lenses+envelopes+and+barbed+wire&amp;ie=utf-8&amp;oe=utf-8&amp;aq=t&amp;rls=org.mozilla:en-US:official&amp;client=firefox-a), I&#39;m stuck on paramorphisms.  Unfortunately the section is quite thin, and the Wikipedia page doesn&#39;t say anything.

My Haskell translation is:

    para :: (a -&gt; [a] -&gt; b -&gt; b) -&gt; b -&gt; [a] -&gt; b
    para f base = h
      where
        h []       =   base
        h (x:xs)   =   f x xs (h xs)

But I don&#39;t grok that -- I don&#39;t have any intuition for the type signature or the desired result.

What&#39;s a paramorphism, and what are some useful examples in action?

---

Yes, I&#39;ve seen [these](https://stackoverflow.com/questions/6941904/recursion-schemes-for-dummies) [questions](https://stackoverflow.com/questions/921972/what-are-zygo-meta-histo-para-futu-dyna-whatever-morphisms), but they don&#39;t cover paramorphisms directly and only point to [resources](http://comonad.com/reader/2009/recursion-schemes/) that may be helpful as references, but not as learning materials.

What are paramorphisms?

I&#39;m trying to visualize some simple automatic physical systems (such things as pendulum, robot arms,etc.) in Haskell.
Often those systems can be described by equations like

`df/dt = c*f(t) + u(t)`

where `u(t)` represents some kind of &#39;intelligent control&#39;. Those systems look to fit very nicely in the Functional Reactive Programming paradigm.

So I grabbed the book &quot;The Haskell School of Expression&quot; by Paul Hudak,
and found that the domain specific language &quot;FAL&quot; (for Functional Animation Language) presented there actually works quite pleasently for my simple toy systems (although some functions, notably `integrate`, seemed to be  a bit too lazy for an efficient use, but easily fixable).

My question is, what&#39;s the more mature, up-to-date, well-maintained, performance-tuned alternative for more advanced, or even practical applications today?

[This wiki page](http://www.haskell.org/haskellwiki/Functional_Reactive_Programming) lists several options for Haskell, but I&#39;m not clear about the following respects:

1. The status of &quot;reactive&quot;, the project from Conal Eliott who is (as I understand it) one of the inventers of this programming paradigm, looks a bit stale. I love his code, but maybe I should try other more up-to-date alternatives? What&#39;s the primary difference between them, in terms of syntax/performance/runtime-stability?

2. To quote from a [survey](http://www.cs.rit.edu/~eca7215/frp-independent-study/Survey.pdf) in 2011, Section 6, &quot;_... FRP implementations are still not efficient enough or predictable enough in performance to be used effectively in domains which require latency guarantees ..._&quot;. Alghough the survey suggests some interesting possible optimizations, given the fact that FRP is there for more than 15 years, I get the impression that this performance problem might be something _very_ or even inherently difficult to solve at least within a few years. Is this true?

3. The same author of the survey talks about &quot;time leaks&quot; in his [blog](http://blog.edwardamsden.com/2011/03/demonstrating-time-leak-in-arrowized.html). Is the problem unique to FRP, or something we are generally having when programming in a pure, non-strict language? Have you ever found it just too difficult to stabilize an FRP-based system over time, if not performant enough?

4. Is this still a research level project? Are the people like plant engineers, robotics engineers, financial engineers, etc. actually using them (in whaterver language that suits their needs)?

Although I personally prefer a Haskell implementation, I&#39;m open to other suggestions. For example, it would be particularly fun to have an Erlang implementation --- it would then be very easy to have an intelligent, adaptive, self-learning server process!


What&#39;s the status of current Functional Reactive Programming implementations?

I&#39;ve seen the term *Free Monad* pop up [every](http://www.haskellforall.com/2012/07/purify-code-using-free-monads.html) [now](http://www.haskell.org/haskellwiki/Free_monad) [and](http://www.haskell.org/pipermail/haskell-cafe/2010-January/072454.html) [then](http://comonad.com/reader/2011/free-monads-for-less/) for some time, but everyone just seems to use/discuss them without giving an explanation of what they are. So: what are free monads? (I&#39;d say I&#39;m familiar with monads and the Haskell basics, but have only a very rough knowledge of category theory.)

What are free monads?

I am currently working my way through the [Learn you a Haskell](http://www.learnyouahaskell.com/for-a-few-monads-more) book online, and have come to a chapter where the author is explaining that some list concatenations can be inefficient: For example

    ((((a ++ b) ++ c) ++ d) ++ e) ++ f

is supposedly inefficient. The solution the author comes up with is to use &#39;difference lists&#39; defined as 

    newtype DiffList a = DiffList {getDiffList :: [a] -&gt; [a] }

    instance Monoid (DiffList a) where
        mempty = DiffList (\xs -&gt; [] ++ xs)
        (DiffList f) `mappend` (DiffList g) = DiffList (\xs -&gt; f (g xs))

I am struggling to understand why `DiffList` is more computationally efficient than a simple concatenation in some cases. Could someone explain to me in simple terms why the above example is so inefficient, and in what way the `DiffList` solves this problem?


Why are difference lists more efficient than regular concatenation in Haskell?

The [`absurd`](http://hackage.haskell.org/packages/archive/void/0.5.10/doc/html/Data-Void.html#v:absurd) function in `Data.Void` has the following signature, where `Void` is the logically uninhabited type exported by that package:

    -- | Since &#39;Void&#39; values logically don&#39;t exist, this witnesses the logical
    -- reasoning tool of \&quot;ex falso quodlibet\&quot;.
    absurd :: Void -&gt; a

I do know enough logic to get the documentation&#39;s remark that this corresponds, by the propositions-as-types correspondence, to the valid formula `⊥ → a`.

What I&#39;m puzzled and curious about is: in what sort of practical programming problems is this function useful?  I&#39;m thinking that perhaps it&#39;s useful in some cases as a type-safe way of exhaustively handling &quot;can&#39;t happen&quot; cases, but I don&#39;t know enough about practical uses of Curry-Howard to tell whether that idea is on the right track at all.

EDIT: Examples preferably in Haskell, but if anybody wants to use a dependently typed language I&#39;m not going to complain...

What&#39;s the absurd function in Data.Void useful for?

I am trying to understand how fold and foldLeft and the respective reduce and reduceLeft work. I used fold and foldLeft as my example

    scala&gt; val r = List((ArrayBuffer(1, 2, 3, 4),10))
    scala&gt; r.foldLeft(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    
    scala&gt; res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5)
    
    scala&gt; r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
    &lt;console&gt;:11: error: value _1 is not a member of Serializable with Equals
                  r.fold(ArrayBuffer(1,2,4,5))((x,y) =&gt; x -- y._1)
       
Why `fold` didn&#39;t work as `foldLeft`? What is `Serializable with Equals`? I understand fold and foldLeft has slight different API signature in terms of parameter generic types. Please advise. Thanks.

Scala : fold vs foldLeft

Consider a single-linked list. It looks something like

    data List x = Node x (List x) | End

It is natural to define a folding function such as

    reduce :: (x -&gt; y -&gt; y) -&gt; y -&gt; List x -&gt; y

In a sense, `reduce f x0` replaces every `Node` with `f` and every `End` with `x0`. This is what the Prelude refers to as a _fold_.

Now consider a simple binary tree:

    data Tree x = Leaf x | Branch (Tree x) (Tree x)

It is similarly natural to define a function such as

    reduce :: (y -&gt; y -&gt; y) -&gt; (x -&gt; y) -&gt; Tree x -&gt; y

Notice that _this_ reduction has a quite different character; whereas the list-based one is inherently sequential, this new tree-based one has more of a divide-and-conquer feel to it. You could even imagine throwing a few `par` combinators in there. (Where would you put such a thing in the list version?)

My question: Is this function still classified as a &quot;fold&quot;, or is it something else? (And if so, what is it?)

Basically whenever anybody talks about folding, they always talk about folding _lists_, which is inherently sequential. I&#39;m wondering whether &quot;sequential&quot; is part of the definition of what a fold is, or whether this is merely a coincidental property of the most commonly-used example of folding.


What constitutes a fold for types other than list?

When should I use `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`, `scanLeft` or `scanRight`?

I want an intuition/overview of their differences - possibly with some simple examples.

Reduce, fold or scan (Left/Right)?

Why do Scala and frameworks like Spark and Scalding have both `reduce` and `foldLeft`? So then what&#39;s the difference between `reduce` and `fold`?

Difference between reduce and foldLeft/fold in functional programming (particularly Scala and Scala APIs)?

I am pretty confused with both functions `fold()` and `reduce()` in Kotlin, can anyone give me a concrete example that distinguishes both of them? 

Content Type	Original Author	Original Content on Stackoverflow
Question	Lethi	View Question on Stackoverflow
Solution 1 - Haskell	AndrewC	View Answer on Stackoverflow

Haskell - foldl and foldr?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

How do I exclude certain modules from a Maven build using the commandline

LINQ to find array indexes of a value

Attributions