I&#39;m trying to define any simple function that spans multiple lines in ghci, take the following as an example:

    let abs n | n &gt;= 0 = n
              | otherwise = -n

So far I&#39;ve tried pressing Enter after the first line:

    Prelude&gt; let abs n | n &gt;= 0 = n
    Prelude&gt;           | otherwise = -n
    &lt;interactive&gt;:1:0: parse error on input `|&#39;

I&#39;ve also attempted to use the `:{` and `:}` commands but I don&#39;t get far:

    Prelude&gt; :{
    unknown command &#39;:{&#39;
    use :? for help.

I&#39;m using GHC Interactive version 6.6 for Haskell 98 on Linux, what am I missing?

How to define a function in ghci across multiple lines?

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;m trying to enable `XRankNTypes` in GHCi.  How do I do this?

How do I enable language extensions from within GHCi?

I&#39;m running into odd behavior with the Interactive-Haskell repl in `emacs`. When I source a file, the `emacs` mini buffer shows a series of interactive prompts:

    Start a new project named &#39;myproject&#39;?
    Cabal dir (guessed from myproject.cabal):
    Build target (empty for default):
    Set current directory:

If I leave either the cabal directory or the current directory to the default value of the project directory, the repl is unresponsive. I get a lambda prompt in the interactive Haskell window, I can type, but when I press enter, it never evaluates. The cursor stays on the same line as if I did not press enter at all. 

If I change both of those directories to some path other than my project directory, then the repl behaves normally and evaluates expressions as expected.


Emacs Interactive-Haskell repl non-response if either the cabal or working directory set to project directory

How can I clear a terminal screen after my user has selected an option from my application&#39;s menu?

How do I clear the terminal screen in Haskell?

I&#39;m trying to make the types ghci displays for my libraries as intuitive as possible, but I&#39;m running into a lot of difficulties when using more advanced type features.

Let&#39;s say I have this code in a file:

    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE TypeOperators #-}
    
    import GHC.TypeLits
    
    data Container (xs::[*]) = Container

I load it up in ghci, then I type the following command:

    ghci&gt; :t undefined :: Container &#39;[String,String,String,String,String]

Unfortunately, ghci gives me the rather ugly looking:

    :: Container
           ((&#39;:)
              *
              String
              ((&#39;:)
                 * String ((&#39;:) * String ((&#39;:) * String ((&#39;:) * String (&#39;[] *))))))
    
ghci has removed the sugar for type level strings.  Is there any way to prevent ghci from doing this and giving me just the pretty version?

----

On a related note, lets say I create a type level `Replicate` function 
    
    data Nat1 = Zero | Succ Nat1
    
    type family Replicate (n::Nat1) x :: [*]
    type instance Replicate Zero x = &#39;[]
    type instance Replicate (Succ n) x = x &#39;: (Replicate n x)

    type LotsOfStrings = Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String

Now, when I ask ghci for a type using `LotsOfStrings`:

    ghci&gt; :t undefined :: Container LotsOfStrings

ghci is nice and gives me the pretty result:

    undefined :: Container LotsOfStrings

But if I ask for the `Replicate`d version,

    ghci&gt; :t undefined :: Container (Replicate (Succ (Succ (Succ (Succ (Succ Zero))))) String)

ghci substitutes in for the type family when it didn&#39;t do that for the type synonym:

    :: Container
           ((&#39;:)
              *
              [Char]
              ((&#39;:)
                 * [Char] ((&#39;:) * [Char] ((&#39;:) * [Char] ((&#39;:) * [Char] (&#39;[] *))))))

Why is ghci doing the substitution for the type family, but not the type synonym?  Is there a way to control when ghci will do the substitution?

Why does ghci desugar type lists and type families? Can this be selectively disabled?

How to I define the equivalent of this function (taken from [learnyouahaskell][1]) inside GHCi?

    import Data.List  
  
    numUniques :: (Eq a) =&gt; [a] -&gt; Int  
    numUniques = length . nub  

Without the type declaration, GHCi accepts the function definition, but it ends up with an unhelpful type:

    Prelude Data.List&gt; import Data.List 
    Prelude Data.List&gt; let numUniques&#39; = length . nub
    Prelude Data.List&gt; :t numUniques&#39;
    numUniques&#39; :: [()] -&gt; Int

The resulting function only accepts a list of units as a parameter.

Is there a way provide type declarations in GHCi? Or is there another way to define functions like these which doesn&#39;t require type declarations?

I saw no obvious clues in the GHCi guide, and experimented with expressions like the following (to no avail):

    &gt; let numUniques&#39; = ((length . nub) :: (Eq a) =&gt; [a] -&gt; Int)
    &gt; :t numUniques&#39;
    numUniques&#39; :: [()] -&gt; Int

  [1]: http://learnyouahaskell.com/

How to provide explicit type declarations for functions when using 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?

What is the best way to test and interact with inner functions defined inside a toplevel function?

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&#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

If you [declare a library + executable sections in a cabal file while avoiding double compilation of the library](https://stackoverflow.com/questions/6711151/how-to-avoid-recompiling-in-this-cabal-file/6711739) by putting the library into a `hs-source-dirs` directory, you cannot usually run your project with `ghci` and `runhaskell` anymore, especially if the executables have helper modules themselves.

What is a recommended project layout that

* only builds what is needed once
* allows using `runhaskell`
* has a clean structure without hacks?

How to make a Haskell cabal project with library+executables that still run with runhaskell/ghci?

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

I have a problem regarding FFI in Haskell and the interactive mode of GHC [again][1].

Consider `FFISo.hs`:

    {-# LANGUAGE OverloadedStrings #-}
    module Main where
    
    import qualified Data.ByteString.Char8 as B
    
    import FFIFun.Foo
    
    main :: IO ()
    main = do
      B.putStrLn &quot;main&quot;
      callMeFromC
      callMeFromHaskell
      return ()

`c.c`:

&lt;!-- language: lang-c --&gt;

    #include &lt;stdio.h&gt;
    
    void callMeFromC(void);
    
    void callMeFromHaskell(void)
    {
        printf(&quot;callMeFromHaskell\n&quot;);
        callMeFromC();
    }

`FFIFun/Foo.hs`:

    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE ForeignFunctionInterface #-}
    module FFIFun.Foo where
    
    import qualified Data.ByteString.Char8 as B
    
    foreign import ccall &quot;callMeFromHaskell&quot;
      callMeFromHaskell :: IO ()
    
    foreign export ccall callMeFromC :: IO ()
    callMeFromC :: IO ()
    callMeFromC = B.putStrLn &quot;callMeFromC&quot;

and a `Makefile`:

&lt;!-- language: none --&gt;

    SHELL := bash
    
    GHC_OPT := -Wall -O2 -fno-warn-unused-do-bind
    
    
    all: ffiso
    
    test: ffiso
        ./$&lt;
    
    ffiso: FFISo.hs c.c
        ghc --make $(GHC_OPT) $^ -o $@
    
    clean:
        rm -rf *{.hi,o,_stub.*} ffiso FFIFun/*{.hi,.o,_stub.*}
    
    ghci: ffiso
        ghci -package bytestring FFIFun/Foo.o c.o FFISo.hs

you find it also [here as a gist][2].

So, my problem now:

&lt;!-- language: none --&gt;

    $ make ghci
    [...]
    Ok, modules loaded: Main, FFIFun.Foo.
    Prelude Main&gt; -- fine, it&#39;s loading.
    Prelude Main&gt; :t callMeFromC
    
    &lt;interactive&gt;:1:1: Not in scope: `callMeFromC&#39;
    Prelude Main&gt; -- uhm, why?
    Prelude Main&gt; :t main
    main :: IO ()
    Prelude Main&gt; main
    
    
    GHCi runtime linker: fatal error: I found a duplicate definition for symbol
       FFIFunziFoo_callMeFromC_info
    whilst processing object file
       ./FFIFun/Foo.o
    This could be caused by:
       * Loading two different object files which export the same symbol
       * Specifying the same object file twice on the GHCi command line
       * An incorrect `package.conf&#39; entry, causing some object to be
         loaded twice.
    GHCi cannot safely continue in this situation.  Exiting now.  Sorry.

Hrmpf, what is wrong here? Interestingly I get an different error on `i686` (above, it&#39;s a `x86_64` system, but both GHC 7.4.1):

&lt;!-- language: none --&gt;

    GHCi runtime linker: fatal error: I found a duplicate definition for symbol
       __stginit_FFIFunziFoo
    whilst processing object file
       ./FFIFun/Foo.o
    This could be caused by:
       * Loading two different object files which export the same symbol
       * Specifying the same object file twice on the GHCi command line
       * An incorrect `package.conf&#39; entry, causing some object to be
         loaded twice.
    GHCi cannot safely continue in this situation.  Exiting now.  Sorry.


Also, is there some documentation about it? I feel like I&#39;m the only one who has hard times with FFI and GHCi out there.

edit:
note, that `make test` works fine:

&lt;!-- language: none --&gt;

    $ ghc --make -Wall -O2 -fno-warn-unused-do-bind FFISo.hs c.c -o ffiso
    [1 of 2] Compiling FFIFun.Foo       ( FFIFun/Foo.hs, FFIFun/Foo.o )
    [2 of 2] Compiling Main             ( FFISo.hs, FFISo.o )
    Linking ffiso ...
    ./ffiso
    main
    callMeFromC
    callMeFromHaskell
    callMeFromC


  [1]: https://stackoverflow.com/questions/10123040/ghci-doesnt-work-with-ffi-export-declarations-shared-libaries
  [2]: https://gist.github.com/2724649

GHCi runtime linker issue when using FFI declarations

I encounter a strange situation in *GHCI*, don&#39;t know if anyone observed similar case. For some module, when I have it in the search path both by `-package-conf`, and also by `-i`, GHCI fails when I try to import the module with `&#39;module is not loaded: FooModule&#39;`.

 - `:module` loads it fine however
 - or I can do `:load FooModule`, `:m` to clear the import list, and then `import FooModule`
 - or I can remove the path from `-i` and then it imports fine

Tracked this to be the `otherwise -&gt; modNotLoadedError m loc` case in [GHC][1], where `otherwise` ~ `modulePackageId = this_pkg` (the meaning of which I don&#39;t know).

This is not entirely systematic, there are some module which are both in package and source path, but can be imported.



  [1]: http://www.haskell.org/ghc/docs/7.4.1/html/libraries/ghc/src/GHC.html

All Ghci Solutions on Gang of Coders

Total of 15 Ghci Solutions