&lt;!-- language-all: groovy --&gt;

There is such a method in groovy, it is called **`collect`**, for example:

    assert [1, 2, 3].collect { it * 2 } == [2, 4, 6]

[1]: http://docs.groovy-lang.org/2.4.3/html/groovy-jdk/java/util/Collection.html#collect()

http://docs.groovy-lang.org/next/html/documentation/working-with-collections.html#_iterating_on_a_list

How do I do I set the syntax highlighting in Vim 7 for python?

I would like to set my own colorschemes, and syntax highlighting for a type of code file.

Syntax highlighting in vim for python

I installed Python 3.1 and the Pygame module for Python 3.1.  When I type `import python` in the console I get the following error:


    Traceback (most recent call last):
      File &quot;&lt;pyshell#2&gt;&quot;, line 1, in &lt;module&gt;
        import pygame
      File &quot;C:\Python31\lib\site-packages\pygame\__init__.py&quot;, line 95, in &lt;module&gt;
        from pygame.base import *
    ImportError: DLL load failed: %1 is not a valid Win32 application.




Solving &quot;DLL load failed: %1 is not a valid Win32 application.&quot; for Pygame

Is there a `map` method in Groovy? I want to do something like I do with the following Scala snippet:

    scala&gt; val l = List(1, 2, 3)
    l: List[Int] = List(1, 2, 3)
    
    scala&gt; l.map(_ + 1)
    res0: List[Int] = List(2, 3, 4)

Groovy map method of collections

Is there a <code>map</code> method in Groovy? I want to do something like I do with the following Scala snippet:
<pre><code class="hljs language-ini">scala> val l = List(1, 2, 3)
l: List[Int] = List(1, 2, 3)

scala> l.map(_ + 1)
res0: List[Int] = List(2, 3, 4)
</code></pre>

Often in the Scala literature, I encounter the phrase &quot;abstract over&quot;, but I don&#39;t understand the intent.  [For example](&lt;http://www.artima.com/scalazine/articles/scalas_type_system.html&gt;), Martin Odersky writes

&gt; You can pass methods (or &quot;functions&quot;) as parameters, or you can _abstract over_ them. You can specify types as parameters, or you can _abstract over_ them. 

As another example, in the [&quot;Deprecating the Observer Pattern&quot;](&lt;http://lamp.epfl.ch/~imaier/pub/DeprecatingObserversTR2010.pdf&gt;) paper, 

&gt; A consequence from our event streams being first-class values is that we can _abstract over_ them. 

I have read that first order generics &quot;abstract over types&quot;, while monads &quot;abstract over type constructors&quot;.  And we also see phrases like this in the [Cake Pattern paper](http://www.scala-lang.org/sites/default/files/odersky/ScalableComponent.pdf).  To quote one of many such examples:

&gt; Abstract type members provide flexible way to _abstract over_ concrete types of components.

Even relevant stack overflow questions use this terminology.  &lt;https://stackoverflow.com/questions/3122398/scala-cant-existentially-abstract-over-parameterized-type&gt;

So... what does &quot;abstract over&quot; actually mean?



What does &quot;abstract over&quot; mean?

I am watching [Runar Bjarnason present Functional Programming for Beginners][1], and at 14:45 he defines a method:

    def isDivisibleBy(k: Int): Int =&gt; Boolean = i =&gt; i % k == 0

and a function:

    val isEven = isDivisibleBy(2)

What are the pros and cons of defining `isEven` as a function rather than a method?

I have read [Scala Functions vs Methods][2] as well as [Difference between method and function in Scala][3], and I understand the semantic differences, but I wonder if there&#39;s some deeper reason in this case why a function might or might not be preferable to using a method:

    def isEven = isDivisibleBy(2)

  [1]: https://www.youtube.com/watch?v=aAtPi23nLcw
  [2]: http://jim-mcbeath.blogspot.com/2009/05/scala-functions-vs-methods.html
  [3]: https://stackoverflow.com/questions/2529184/difference-between-method-and-function-in-scala

Functions vs methods in Scala

Recently scalaz caught my eye. It looks very interesting, but I have not found any good introduction to the library. Seems that scalaz incorporates a lot of ideas from haskell and mathematics. Most articles that I found assume that you already feel comfortable with these concepts.

What I&#39;m looking for is gradual introduction to the library and underlying concepts - from simple and basic concepts to more advanced (which basesd in basics).

I also looked to the [examples](http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/example/Example.scala.html), but it&#39;s hard for me to find the point where I should start to learn library.

**Can somebody recommend me some good scalaz introduction or tutorial (that covers basics and advanced concepts)? Or give me starting point in the answer.**

---
## Update

Thanks everybody for the great answers! I summarized all of the answers and added some more links in my blog:

https://github.com/OlegIlyenko/hacking-scala-blog/blob/master/posts/Scalaz-Resources-For-Beginners.md

And for those stuggling to find the API documentation for Scalaz they are here:

http://docs.typelevel.org/api/scalaz/nightly/index.html#package

Good scalaz introduction

I am having a discussion around *[Multiple Parameter Lists][1]* in the Scala Style Guide I maintain. I&#39;ve come to realize that there are two ways of [currying][2], and I&#39;m wondering what the use cases are:

    def add(a:Int)(b:Int) = {a + b}
    // Works
    add(5)(6)
    // Doesn&#39;t compile
    val f = add(5)
    // Works
    val f = add(5)_
    f(10) // yields 15

    def add2(a:Int) = { b:Int =&gt; a + b }
    // Works
    add2(5)(6)
    // Also works
    val f = add2(5)
    f(10) // Yields 15
    // Doesn&#39;t compile
    val f = add2(5)_

The style guide incorrectly implies these are the same, when they are clearly not. The guide is trying to make a point about created curried functions, and, while the second form is not &quot;by-the-book&quot; currying, it&#39;s still very similar to the first form (though arguably easier to use because you don&#39;t need the `_`)

From those that use these forms, what&#39;s the consensus on when to use one form over the other?

  [1]: http://davetron5000.github.com/scala-style/declarations/methods/currying.html
  [2]: http://en.wikipedia.org/wiki/Currying


Two ways of currying in Scala; what&#39;s the use-case for each?

I am trying to avoid constructs like this:

    val result = this.getClass.getSimpleName
    if (result.endsWith(&quot;$&quot;)) result.init else result

Ok, in this example the `then` and `else` branch are simple, but you can image complex ones.
I built the following:

    object TernaryOp {
      class Ternary[T](t: T) {
        def is[R](bte: BranchThenElse[T,R]) = if (bte.branch(t)) bte.then(t) else bte.elze(t)
      }
      class Branch[T](branch: T =&gt; Boolean) {
        def ?[R] (then: T =&gt; R) = new BranchThen(branch,then)
      }
      class BranchThen[T,R](val branch: T =&gt; Boolean, val then: T =&gt; R)
      class Elze[T,R](elze: T =&gt; R) {
        def :: (bt: BranchThen[T,R]) = new BranchThenElse(bt.branch,bt.then,elze)
      }
      class BranchThenElse[T,R](val branch: T =&gt; Boolean, val then: T =&gt; R, val elze: T =&gt; R)
      implicit def any2Ternary[T](t: T) = new Ternary(t)
      implicit def fct2Branch[T](branch: T =&gt; Boolean) = new Branch(branch)
      implicit def fct2Elze[T,R](elze: T =&gt; R) = new Elze(elze)
    }

Defined that, I can replace the above simple example with:

    this.getClass.getSimpleName is {s: String =&gt; s.endsWith(&quot;$&quot;)} ? {s: String =&gt; s.init} :: {s: String =&gt; s}

But how can I get rid of the `s: String =&gt;`? I want something like that:

    this.getClass.getSimpleName is {_.endsWith(&quot;$&quot;)} ? {_.init} :: {identity}

I guess the compiler needs the extra stuff to infer types.



Ternary Operator Similar To ?:

It is often desired to declare constants at the top of a script that can be referenced anywhere else in the script.  In Groovy, it seems that if you declare a constant using final &lt;type&gt; then it isnot accessible in child scopes.  What is the solution for this very basic and common requirement?  The workaround I have right now is to create an unbound variable but this is not a constant and is not elegant.

Global constants in Groovy

    def map = [name:&quot;Gromit&quot;, likes:&quot;cheese&quot;, id:1234]

I would like to access map in such a way that I can get the key

something like the output should be

map.keys returns array of string. basically i just want to get the keys

output:

    name
    likes
    id

Get key in groovy maps

With:

    Object method(){
        ...
        return /* some complex expression */
    }

Is there a way I can see what value will be returned while debugging? Like somehow set a breakpoint that would be hit right after the return, but before execution goes to the calling code?  I&#39;d like to be able to know what the return value is and also be able to see what values of all of the local variables are.

The way I do it now is by making a temporary variable: `Object ret = /* something complex */; return ret;`. But thats a hassle and also adds an extra unnecessary line of code.


Note: This is the same question as https://stackoverflow.com/questions/268048/can-i-find-out-the-return-value-before-returning-while-debugging-in-visual-studio, but for intellij.

Can I find out the return value before returning while debugging in Intellij?

Groovy scripts raises an error:

    def a = &quot;test&quot;
      + &quot;test&quot;
      + &quot;test&quot;

Error:

    No signature of method: java.lang.String.positive() is 
    applicable for argument types: () values: []

While this script works fine:

    def a = new String(
      &quot;test&quot;
      + &quot;test&quot;
      + &quot;test&quot;
    )

Why?

What&#39;s wrong with Groovy multi-line String?

What the performance of Groovy compared with Java?

How is the performance of Groovy compared with Java?

I&#39;m trying to learn about new usages of javascript as a serverside language and as a functional language. Few days ago I heard about node.js and express framework. Then I saw about underscore.js as a set of utility functions. I saw [this question on stackoverflow
][1]. It says we can use underscore.js as a template engine. anybody know good tutorials about how to use underscore.js for templating, especially for biginners who have less experience with advanced javascript. Thanks 

  [1]: https://stackoverflow.com/questions/1787716/is-there-a-template-engine-for-node-js

How to use underscore.js as a template engine?

In Javascript, how can one determine the number of formal parameters defined for a function?

Note, this is not the `arguments` parameter when the function is called, but the number of named arguments the function was defined with.

    function zero() {
        // Should return 0
    }

    function one(x) {
        // Should return 1
    }

    function two(x, y) {
        // Should return 2
    }



Get a function&#39;s arity

Software Engineering as it is taught today is entirely focused on object-oriented programming and the &#39;natural&#39; object-oriented view of the world. There is a detailed methodology that describes how to transform a domain model into a class model with several steps and a lot of (UML) artifacts like use-case-diagrams or class-diagrams. Many programmers have internalized this approach and have a good idea about how to design an object-oriented application from scratch. 

The new hype is functional programming, which is taught in many books and tutorials. But what about functional software engineering? 
While reading about Lisp and Clojure, I came about two interesting statements: 

1. Functional programs are often developed bottom up instead of top down (&#39;On Lisp&#39;, Paul Graham)

2. Functional Programmers use Maps where OO-Programmers use objects/classes (&#39;Clojure for Java Programmers&#39;, talk by Rich Hickley). 

So what is the methodology for a systematic (model-based ?) design of a functional application, i.e. in Lisp or Clojure? What are the common steps, what artifacts do I use, how do I map them from the problem space to the solution space? 



Is there a software-engineering methodology for functional programming?

Is there a javascript equivalent of Python&#39;s zip function?  That is, given multiple arrays of equal lengths create an array of pairs.

For instance, if I have three arrays that look like this:

    var array1 = [1, 2, 3];
    var array2 = [&#39;a&#39;,&#39;b&#39;,&#39;c&#39;];
    var array3 = [4, 5, 6];

The output array should be:

    var output array:[[1,&#39;a&#39;,4], [2,&#39;b&#39;,5], [3,&#39;c&#39;,6]]




Javascript equivalent of Python&#39;s zip function

The terms do appear to be  *defined* differently, but I&#39;ve always thought of one implying the other; I can&#39;t think of any case when an expression is referentially transparent but not pure, or vice-versa. 

Wikipedia maintains separate articles for these concepts and says:

From [Referential transparency][1]:

&gt; If all functions involved in the
&gt; expression are pure functions, then
&gt; the expression is referentially
&gt; transparent. Also, some impure
&gt; functions can be included in the
&gt; expression if their values are
&gt; discarded and their side effects are
&gt; insignificant.
&gt; 

From [Pure expressions][2]:

&gt; 
&gt; Pure functions are required to
&gt; construct pure expressions. [...] Pure
&gt; expressions are often referred to as
&gt; being referentially transparent.

I find these statements confusing. If the side effects from a so-called &quot;impure function&quot; are *insignificant* enough to allow not performing them (i.e. replace a call to such a function with its *value*) without materially changing the program, it&#39;s the same as if it were pure in the first place, isn&#39;t it?

Is there a simpler way to understand the differences between a pure expression and a referentially transparent one, if any? If there is a difference, an example expression that clearly demonstrates it would be appreciated. 


  [1]: http://en.wikipedia.org/wiki/Referential_transparency_(computer_science)#Examples_and_counterexamples
  [2]: http://en.wikipedia.org/wiki/Pure_function#Pure_expressions

Purity vs Referential transparency

I&#39;m using `map` in C++.  Suppose I have 10 values in the `map` and I want only the first one. How do I get it?

Thanks.

Getting first value from map in C++

I have Googled this and got patchy / contradictory opinions - is there actually any difference between doing a `map` and doing a `collect` on an array in Ruby/Rails? 

The &lt;a href=&quot;http://www.ruby-doc.org/core/classes/Array.html#M000248&quot;&gt;docs&lt;/a&gt; don&#39;t seem to suggest any, but are there perhaps differences in method or performance?

Difference between map and collect in Ruby?

I&#39;m looking for the fastest algorithm for grouping points on a map into equally sized groups, by distance. The [k-means clustering algorithm][1] looks straightforward and promising, but does not produce equally sized groups.

Is there a variation of this algorithm or a different one that allows for an equal count of members for all clusters?


  [1]: http://en.wikipedia.org/wiki/K-means_clustering

&gt; See also: https://stackoverflow.com/questions/8796682/group-n-points-in-k-clusters-of-equal-size

K-means algorithm variation with equal cluster size

When creating a `Map` in scala, I call `Map(entities.map{e =&gt; e.id -&gt; e})`, and I get:

    found   : scala.collection.mutable.IndexedSeq[(Int, Entity)]
    required: (Int, Entity)

This is because the signature for `Map.apply` is: `def apply[A, B](elems: (A, B)*): CC[A, B]`,
which requires a varargs style argument.

Is there a way to convert the `IndexedSeq` so that it can be accepted via `Map.apply`?


scala: How to pass an expanded list as varargs into a method?

I have a map&lt;string, int&gt; to count the occurrence of words in a file.
I am reading words from the file, and each time I read a word I want to do this:

    map[word]++; //(where map is the name of my map, I&#39;m not using map as a name of course)
so that if the my map already has &#39;word&#39; as a key, it increments it, otherwise it creates the new key and increments it.

Here&#39;s where I am concerned: if I do map[word]++ on a new key (which is unavoidable in the first word read), will my program crash because the int in my map&lt;string, int&gt; is unitialized?
If so, what&#39;s the most efficient way of telling my map: if the word is already there, do ++ on the value, otherwise, create the new key with value = 1?
Using an if statement with &#39;map.find&#39; here seems unnecessarily redundant, what do you think?

Thanks

Content Type	Original Author	Original Content on Stackoverflow
Question	deamon	View Question on Stackoverflow
Solution 1 - Scala	IttayD	View Answer on Stackoverflow

Groovy map method of collections

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solving "DLL load failed: %1 is not a valid Win32 application." for Pygame

Syntax highlighting in vim for python

Attributions