Have you tried adding `:set prompt &quot;ghci&gt; &quot;` to [~/.ghci][1]?

  [1]: http://www.haskell.org/ghc/docs/6.8.2/html/users_guide/ghci-dot-files.html

Having applied @hvr&#39;s answer I got the following warning:

```none
*** WARNING: ~/.ghci is writable by someone else, IGNORING!
```

The solution is `chmod g-w ~/.ghci`.

In my `~/.ghci` configuration file. I have the following line:

`:set prompt &quot;\ESC[0;34m\STX%s\n\ESC[1;31m\STXλ&gt; \ESC[m\STX&quot;`

And here is how my `ghci` prompt looks like:

https://asciinema.org/a/Tpk5430dPqCRN0cFqi1ucaCb8

In that config file, I temporarily commented out `:set +m`. 

In [@truthadjustr&#39;s answer][1] the prelude comes every time you run any command.

`:set prompt &quot;\ESC[1;31m\STXλ&gt; \ESC[m\STX&quot;
` 

This command solves the problem.


  [1]: https://stackoverflow.com/a/53109980/208273


I&#39;m using Django with an sqlite backend, and write performance is a problem.  I may graduate to a &quot;proper&quot; db at some stage, but for the moment I&#39;m stuck with sqlite.  I think that my write performance problems are probably related to the fact that I&#39;m creating a large number of rows, and presumably each time I `save()` one it&#39;s locking, unlocking and syncing the DB on disk.

How can I aggregate a large number of `save()` calls into a single database operation?

Aggregating save()s in Django?

I have come across the following code in C#.

    if(condition0) statement0;
    else if(condition1) statement1;
    else if(condition2) statement2;
    else if(condition3) statement3;
    ...
    else if(conditionN) statementN;
    else lastStatement;

Some of my colleagues tell me that this is an `else if` statement.  However, I am convinced that it is actually a multi-layered nested `if-else` statement. I know that without delimiters `{}`, one statement is allowed in an `if` or `else`. So in this case I think it would be equivalent to the following code.

    if(condition0) 
      statement0;
    else
      if(condition1)
        statement1;
      else
        if(condition2)
          statement2;
        else
          if(condition3)
            statement3;
          else
          ...

Note that all I changed was the whitespace.
This indentation works because each `else` goes back to the most recent `if` statement when there are no delimiters.

Can anyone clarify if the `else if` format in the first example is treated differently by the compiler than the nested `if-else` format in the second example?


  


Do else if statements exist in C#?

I&#39;m using ghci 6.8.2 on Ubuntu. Does ghci use a configuration file where we can do some initial setup?. E.g.: `:set prompt &quot;ghci&gt; &quot;`.


ghci configuration file

<p>I'm using ghci 6.8.2 on Ubuntu. Does ghci use a configuration file where we can do some initial setup?. E.g.: <code>:set prompt "ghci> "</code>.</p>


Is it possible to have guards on lambda functions?

For example:

    \k
        | k &lt; 0     -&gt; &quot;negative&quot;
        | k == 0    -&gt; &quot;zero&quot;
        | otherwise -&gt; &quot;positive&quot;



Haskell guards on lambda functions?

In Haskell, what is the difference between an `Int` and an `Integer`? Where is the answer documented?

What is the difference between Int and Integer?

I wanted to test foldl vs foldr. From what I&#39;ve seen you should use foldl over foldr when ever you can due to tail reccursion optimization.

This makes sense. However, after running this test I am confused:

foldr (takes 0.057s when using time command):

    a::a -&gt; [a] -&gt; [a]
    a x = ([x] ++ )
    
    main = putStrLn(show ( sum (foldr a [] [0.. 100000])))

    
foldl (takes 0.089s when using time command):

    b::[b] -&gt; b -&gt; [b]
    b xs = ( ++ xs). (\y-&gt;[y])
    
    main = putStrLn(show ( sum (foldl b [] [0.. 100000])))

It&#39;s clear that this example is trivial, but I am confused as to why foldr is beating foldl. Shouldn&#39;t this be a clear case where foldl wins?
    


foldl is tail recursive, so how come foldr runs faster than foldl?

I need a function which takes an arbitrary number of arguments (All of the same type), does something with them and afterwards gives a result back. A list of arguments is impracticable in my specific case.

As I looked through the haskell libs, I saw that the function `printf` (from module `Text.Printf`) uses a similar trick. Unfortunately, I couldn&#39;t understand that magic by looking at the source.

Can somebody explain how to achieve this, or at least some webpage/paper/whatever where I could find a good description for this?

**Motivation:**

The reason I need this is really quite simple. For school (computer science class), we are required to write a module that is able to &quot;record&quot; a mathematical expression, express it as a string (Via writing an instance of Num/Real/etc for an own datatype), and perform various operations on it.  

This datatype contains a special constructor for a variable, which may be replaced by a value or whatever by a specified function. One of the goals is to write a function, which takes such an expression with some number of variables (pairs of type `(Char,Rational)`) and calculates the result of the expression. We should look at how to express the goal of the function best. (My idea: The function returns another function which takes exactly as many arguments as vars that are defined in the function - seems to be impossible).

How to create a polyvariadic haskell function?

coming from the Ocaml community, I&#39;m trying to learn a bit of Haskell. The transition goes quite well but I&#39;m a bit confused with debugging. I used to put (lots of) &quot;printf&quot; in my ocaml code, to inspect some intermediate values, or as flag to see where the computation exactly failed.

Since printf is an **IO** action, do I have to lift all my haskell code inside the **IO** monad to be able to this kind of debugging ? Or is there a better way to do this (I really don&#39;t want to do it by hand if it can be avoided)

I also find the **trace** function : 
http://www.haskell.org/haskellwiki/Debugging#Printf_and_friends
which seems exactly what I want, but I don&#39;t understand it&#39;s type: there is no **IO** anywhere!
Can someone explain me the behaviour of the trace function ?

How to &quot;debug&quot; Haskell with printfs?

I&#39;m going through the &#39;Learn you a Haskell&#39; tutorial and I am at this part:

    lucky :: (Integral a) =&gt; a -&gt; String

When I try to execute this line I get:

    &lt;interactive&gt;:1:1: Not in scope: `lucky&#39;

What am I doing wrong?

ghci &#39;Not in scope:&#39; message

I&#39;m using Haskell 2010.1.0.0.1 with GHC 6. Typing `:t` at the GHCi prompt followed by the name of a function shows us the type of the function. Is there a way to view the function definition as well?

How can I view the definition of a function in Haskell/GHCi?

I am having problem in entering multi-line commands in ghci.

The following 2-line code works from a file:

    addTwo :: Int -&gt; Int -&gt; Int
    addTwo x y = x + y

But when I enter in ghci, I get an error:

&lt;!-- language: none --&gt;

    &lt;interactive&gt;:1:1: error:
        Variable not in scope: addTwo :: Int -&gt; Int -&gt; Int

I also tried putting the code inside `:{ ... :}`, but they are also not working for this example, because this is just appending the lines into one line, which should not be the case.

I am using WinGHCi, version 2011.2.0.1



Multi-line commands in GHCi

I&#39;ve been told you can interpret Haskell files (which I assume means they will work like Ruby/Python/Perl). I can&#39;t find the command line option on GHC to do this, though. It always wants to compile my file. Took a look at GHCi as well, but it always dumps me into a repl.

I&#39;m basically wanting to just do `ghc -i MyFile.hs` (where -i is a made up flag that I&#39;m pretending correllates to interpreted mode) and have it execute so that I can get quick feedback while I&#39;m trying out ideas and learning.


How to run a Haskell file in interpreted mode

When I program in Javascript, I find it *extremely* convenient to be able to use the debugger to halt program execution at any point and to be able to runs commands and inspect variables from there.

Now, back in Haskell, is there a way to run arbitrary functions in the interactive GHCI REPL or am I limited to things declared at the toplevel?

What is the &quot;standard&quot; approach to working and debugging inner functions and values?

Content Type	Original Author	Original Content on Stackoverflow
Question	rturrado	View Question on Stackoverflow
Solution 1 - Haskell	hvr	View Answer on Stackoverflow
Solution 2 - Haskell	sjakobi	View Answer on Stackoverflow
Solution 3 - Haskell	eigenfield	View Answer on Stackoverflow
Solution 4 - Haskell	Abhinav	View Answer on Stackoverflow

ghci configuration file

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Solution 3 - Haskell

Solution 4 - Haskell

Do else if statements exist in C#?

Aggregating save()s in Django?

Attributions