You may want to investigate [Frege](https://github.com/Frege/frege). Quoting from that page:

&gt; &quot;Frege is a non-strict, pure functional programming language in the spirit of Haskell.&quot;
&gt;
&gt; &quot;Frege programs are compiled to Java and run in a JVM.&quot;

Based on a brief perusal of the language specification, Frege looks to be nearly a Haskell clone. Perhaps the phrase &quot;in the spirit of Haskell&quot; is simpy intended to set the proper expectation.

Haskell works beautifully on the JVM. See [Eta][1], a project that brings full GHC 7.10.3 Haskell onto the JVM with type-safe Java interop.


  [1]: https://github.com/typelead/eta

The only language I know that is close to haskell in the JVM is CAL. CAL is heavily based on haskell but it doesn&#39;t have all haskell&#39;s features. The type system is similar to Haskell 98, and syntactic sugar like `do` notation is missing.

Here&#39;s a comparison of Haskell and CAL: [CAL for Haskell Programmers](https://github.com/levans/Open-Quark)

The eclipse plugin is very polished and useful.

Note that CAL is part of the Open Quark framework.

* main site: [http://openquark.org/Welcome.html](http://openquark.org/Welcome.html)
* download page: [http://openquark.org/Download.html](http://openquark.org/Download.html)
* Source on Github: [https://github.com/levans/Open-Quark](https://github.com/levans/Open-Quark)

There are big but surmountable impediments to GHC building to the JVM:  
  
http://www.haskell.org/haskellwiki/GHC:FAQ#Why_isn.27t_GHC_available_for_.NET_or_on_the_JVM.3F

(Got a spare year or two to make it happen?)

I am having a strange issue with iTerm2, in terminal vim (non-gui) and the solarized color scheme. First, I have set iTerm2 to use the dark solarized colour scheme.

I am also using solarized for vim. I have the following lines in my .vimrc

    set background=dark
    colorscheme solarized

In the terminal the color scheme looks incorrect:
![console vim][1]

For reference this is how it looks under MacVim (gui vim)
![gui vim][2]

What do I need to change in iTerm or my .vimrc to get the colors looking correctly in my console vim?

  [1]: http://i.stack.imgur.com/Tc9bq.png
  [2]: http://i.stack.imgur.com/Tao1x.png

Incorrect colors with vim in iTerm2 using Solarized

I am nearly landed at Cassandra after my research on large scale data storage solutions. But its generally said that Hbase is better solution for large scale data processing and analysis. 

While both are same key/value storage and both are/can run (Cassandra recently) Hadoop layer then what makes Hadoop a better candidate when processing/analysis is required on large data.

I also found good details about both at
http://ria101.wordpress.com/2010/02/24/hbase-vs-cassandra-why-we-moved/ 

but I&#39;m still looking for concrete advantages of Hbase.

While I am more convinced about Cassandra because its simplicity for adding nodes and seamless replication and no point of failure features. And it also keeps secondary index feature so its a good plus.

Large scale data processing Hbase vs Cassandra

I&#39;m wondering if there is some way to make Haskell run on the JVM (compiled or interpreted)?

There exists JHaskell on Sourceforge but this one seems to be empty and dead.

GHC uses LLVM as compiler backend. Would it be a good idea or possible to compile LLVM to Java bytecode? Or maybe use a different compiler backend?


Haskell on JVM?

I'm wondering if there is some way to make Haskell run on the JVM (compiled or interpreted)?
There exists JHaskell on Sourceforge but this one seems to be empty and dead.
GHC uses LLVM as compiler backend. Would it be a good idea or possible to compile LLVM to Java bytecode? Or maybe use a different compiler backend?

Good day. 

The one thing I now hate about Haskell is quantity of packages for working with string.

First I used native Haskell `[Char]` strings, but when I tried to start using hackage libraries then completely lost in endless conversions. Every package seem to use different strings implementation, some adopts their own handmade thing.

Next I rewrote my code with `Data.Text` strings and `OverloadedStrings` extension, I chose `Text` because it has a wider set of functions, but it seems many projects prefer `ByteString`.&lt;br /&gt;
Someone could give short reasoning why to use one or other?

PS: btw how to convert from `Text` to `ByteString`?

&gt; Couldn&#39;t match expected type
&gt; *Data.ByteString.Lazy.Internal.ByteString*
&gt;            against inferred type *Text*
&gt;       Expected type: IO Data.ByteString.Lazy.Internal.ByteString
&gt;       Inferred type: IO Text

I tried `encodeUtf8` from `Data.Text.Encoding`, but no luck:

&gt; Couldn&#39;t match expected type
&gt; *Data.ByteString.Lazy.Internal.ByteString*
&gt;            against inferred type *Data.ByteString.Internal.ByteString*


**UPD:**

Thanks for responses, that *Chunks goodness looks like way to go, but I somewhat shocked with result, my original function looked like this:

    htmlToItems :: Text -&gt; [Item]
    htmlToItems =
        getItems . parseTags . convertFuzzy Discard &quot;CP1251&quot; &quot;UTF8&quot;


And now became:

    htmlToItems :: Text -&gt; [Item]
    htmlToItems =
        getItems . parseTags . fromLazyBS . convertFuzzy Discard &quot;CP1251&quot; &quot;UTF8&quot; . toLazyBS
        where
          toLazyBS t = fromChunks [encodeUtf8 t]
          fromLazyBS t = decodeUtf8 $ intercalate &quot;&quot; $ toChunks t


And yes, this function is not working because its wrong, if we supply `Text` to it, then we&#39;re confident this text is properly encoded and ready to use and converting it is stupid thing to do, but such a verbose conversion still has to take place somewhere outside `htmltoItems`.

Text or Bytestring

I have issues with the following passage from [Learn You A Haskell][1] (Great book imo, not dissing it):

&gt; One big difference is that right
&gt; folds work on infinite lists, whereas left ones don&#39;t! To put it
&gt; plainly, if you take an infinite list at some point and you fold it up
&gt; from the right, you&#39;ll eventually reach the beginning of the list.
&gt; However, if you take an infinite list at a point and you try to fold
&gt; it up from the left, you&#39;ll never reach an end!

    
I just don&#39;t get this. If you take an infinite list and try to fold it up from the right then you&#39;ll have to start at the point at infinity, which just isn&#39;t happening (If anyone knows of a language where you can do this do tell :p). At least, you&#39;d have to start there according to Haskell&#39;s implementation because in Haskell foldr and foldl don&#39;t take an argument that determines where in the list they should start folding.

I would agree with the quote iff foldr and foldl took arguments that determined where in the list they should start folding, because it makes sense that if you take an infinite list and start folding right from a defined index it *will* eventually terminate, whereas it doesn&#39;t matter where you start with a left fold; you&#39;ll be folding towards infinity. However foldr and foldl *do not* take this argument, and hence the quote makes no sense. In Haskell, both a left fold and a right fold over an infinite list **will not terminate**.

Is my understanding correct or am I missing something?


  [1]: http://learnyouahaskell.com/higher-order-functions#folds

Left and Right Folding over an Infinite list

Looking through the Haskell Prelude, I [see a function][1] `const`:

    const x _ = x

I can&#39;t seem to find anything relevant regarding this function.

What&#39;s the point? Can anyone give an example of where this function might be used?


  [1]: http://hackage.haskell.org/package/base-4.9.0.0/docs/src/GHC.Base.html#const

What&#39;s the point of &#39;const&#39; in the Haskell Prelude?

I was just doing some Haskell development and I recompiled some old code on a new version of GHC:

    The Glorious Glasgow Haskell Compilation System, version 7.2.1

And when I did I received the following error:

&gt; Warning: -XDatatypeContexts is deprecated: It was widely considered a misfeature, and has been removed from the Haskell language.

That appears when you have code in the following format:

    data Ord a =&gt; MyType a
        = ConstructorOne a
        | ConstructorTwo a a

My question is: Why was this feature deprecated in the first place and what am I supposed to do instead to achieve the same or similar functionality?

DatatypeContexts Deprecated in Latest GHC: Why?

I am trying and failing to grok the `traverse` function from `Data.Traversable`. I am unable to see its point. Given that I come from an imperative background, can someone please explain it to me in terms of an imperative loop? Pseudo-code would be much appreciated. Thanks.

Can someone explain the traverse function in Haskell?

I am getting this error message when I start Eclipse Helios on Windows 7:

&gt; Failed to create the Java Virtual Machine

![Enter image description here][1]

My eclipse.ini looks as follows:

    -startup
    plugins/org.eclipse.equinox.launcher_1.1.0.v20100507.jar
    -vm
    P:\Programs\jdk1.6\bin
    --launcher.library
    plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.0.v20100503
    -product
    org.eclipse.epp.package.jee.product
    --launcher.defaultAction
    openFile
    -showsplash
    org.eclipse.platform
    --launcher.XXMaxPermSize
    512m
    --launcher.defaultAction
    openFile
    -vmargs
    -Dosgi.requiredJavaVersion=1.5
    -Xms120m
    -Xmn100m
    -Xmx1024m

My JAVA_HOME is correctly set as far as I can tell. How can I fix this?

Things I have tried so far:
---------------------------

 1. Adding the full path to javaw.exe
   `-vm
    P:\Programs\jdk1.6\bin\\bin\javaw.exe`
 2. Removing the `-vm` option altogether
 3. Removing `--launcher.XXMaxPermSize` fixes the issue, but it causes permgen errors
 4. Removing the value `512` of `--launcher.XXMaxPermSize` fixes the issue, but it causes permgen errors
 5. Reducing `-Xmx` to `512m` also fixes the issue.

Why can I not use &#39;1024m&#39; for &#39;-Xmx&#39; and &#39;--launcher.XXMaxPermSize&#39;?

  [1]: http://i.stack.imgur.com/YYgjc.png


Eclipse error: &#39;Failed to create the Java Virtual Machine&#39;

Given the following constructs for defining a function in Scala, can you explain what the difference is, and what the implications will be?

    def foo = {}

vs.

    def foo() = {}


*Update*

Thanks for the quick responses.  These are great.  The only question that remains for me is:

If I omit the parenthesis, is there still a way to pass the function around?  This is what I get in the repl:

    scala&gt; def foo = {}
    foo: Unit
    
    scala&gt; def baz() = {}
    baz: ()Unit
    
    scala&gt; def test(arg: () =&gt; Unit) = { arg }
    test: (arg: () =&gt; Unit)() =&gt; Unit
    
    scala&gt; test(foo)
    &lt;console&gt;:10: error: type mismatch;
     found   : Unit
     required: () =&gt; Unit
                  test(foo)
                       ^
    
    scala&gt; test(baz)
    res1: () =&gt; Unit = &lt;function0&gt;
    
----------

***Update 2012-09-14***

Here are some similar questions I noticed:

 1. https://stackoverflow.com/q/7600910/293064
 2. https://stackoverflow.com/q/6939908/293064

What is the difference between def foo = {} and def foo() = {} in Scala?

Can someone please explain what the JVM option `ReservedCodeCacheSize` and `InitialCodeCacheSize` are? Specifically when/why would I want to change it? How do I decide what the right size is?

This is what the docs say:

&gt;-XX:ReservedCodeCacheSize=32m 	Reserved code cache size (in bytes) - maximum code cache size. [Solaris 64-bit, amd64, and -server x86: 2048m; in 1.5.0_06 and earlier, Solaris 64-bit and and64: 1024m.]

What are ReservedCodeCacheSize and InitialCodeCacheSize?

I have some Junit unit tests that require a large amount of heap-space to run - i.e. 1G. (They test memory-intensive functionality for a webstart app that will only run with sufficient heap-space, and will be run internally on Win 7 64-bit machines - so redesigning the tests isn&#39;t a practical suggestion.)

I am developing in Intellij IDEA, so I know I can set the JVM parameters (e.g. -Xmx1024M) for the test class. However, this is only for running the whole test class - if I want to run an individual test, I have to recreate the run congfigurations for that test method. 

Also, those are IDE and box specific - so if I switch boxes (I develop on multiple machines) or one of my colleagues tries to run the tests, those settings are not transferred. (Also, other IDEs like Eclipse and NetBeans are used by my colleagues.) FWIW, we&#39;re using mercurial for source code control.

For the build cycle, we&#39;re using Maven, so I know how to specify the JVM parameters for that.

So:
- I&#39;m looking for a way of specifying the JVM parameters that will apply for the whole test class and the individual test methods; and
- I&#39;d like to share those specification across IDEs on any machine (having picked up the code from the repository).

How to set JVM parameters for Junit Unit Tests?

I have a very basic question about JVM: is it a compiler or an interpreter?

If it is an interpreter, then what about JIT compiler that exist inside the JVM?  
If neither, then what exactly is the JVM? (I dont want the basic definition of jVM of converting byte code to machine specific code etc.)

Is the JVM a compiler or an interpreter?

Is there anything similar to Python [virtualenv][1] for Java or JVM Languages?

  [1]: http://www.virtualenv.org/en/latest/index.html#virtualenv

Is there anything like VirtualEnv for Java?

This question came up after reading the [Loom proposal][1], which describes an approach of implementing coroutines in the Java programming language.

Particularly this proposal says that to implement this feature in the language, additional JVM support will be required.

As I understand it there are already several languages on the JVM that have coroutines as part of their feature set such as Kotlin and Scala.

So how is this feature implemented without additional support and can it be implemented efficiently without it?


  [1]: http://cr.openjdk.java.net/~rpressler/loom/Loom-Proposal.html

Content Type	Original Author	Original Content on Stackoverflow
Question	jeha	View Question on Stackoverflow
Solution 1 - Haskell	Daniel Pratt	View Answer on Stackoverflow
Solution 2 - Haskell	rahulmutt	View Answer on Stackoverflow
Solution 3 - Haskell	islon	View Answer on Stackoverflow
Solution 4 - Haskell	amindfv	View Answer on Stackoverflow

Haskell on JVM?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Solution 3 - Haskell

Solution 4 - Haskell

Large scale data processing Hbase vs Cassandra

Incorrect colors with vim in iTerm2 using Solarized

Attributions