Not currently. 

The closest command to what you want is `:info`

&gt; :info name ...
&gt;
&gt; Displays information about the given name(s). For example, if name is a class, then the class methods and their types will be printed; if name is a type constructor, then its definition will be printed; if name is a function, then its type will be printed. If name has been loaded from a source file, then GHCi will also display the location of its definition in the source.
&gt;   
&gt; For types and classes, GHCi also summarises instances that mention them. To avoid showing irrelevant information, an instance is shown only if (a) its head mentions name, and (b) all the other things mentioned in the instance are in scope (either qualified or otherwise) as a result of a :load or :module commands.

like so:

    Prelude&gt; :info ($)
    ($) :: (a -&gt; b) -&gt; a -&gt; b 	-- Defined in GHC.Base
    infixr 0 $

You can though, see the source for identifiers generated by the haddock tool, on Hackage.

 1. [Look up the module on Hackage][1]
 1. [Click on the source link][2]

Note that &quot;?src&quot; *is* a valid command in lambdabot, on the #haskell IRC channel, and does what you&#39;d expect.

    &gt; ?src ($)
    &gt; f $ x = f x


  [1]: http://hackage.haskell.org/packages/archive/base/4.3.1.0/doc/html/Prelude.html#v:-36-
  [2]: http://hackage.haskell.org/packages/archive/base/4.3.1.0/doc/html/src/GHC-Base.html#%24

I don&#39;t think so.  You can use `:i` for a little bit more information (more useful for infix operators and data constructions, etc.), but not the definition:

    ghci&gt; :i repeat
    repeat :: a -&gt; [a]       -- Defined in GHC.List

You can use [hoogle](http://haskell.org/hoogle/?q=repeat) to quickly find the documentation for a standard library function, which on the right has a link to go to the source.  It&#39;s still a few clicks away though.

Nope, can&#39;t do that.  Some fun things you, the Haskell beginner, can do:

 - On the HTML haddock documents, click on &quot;source&quot;... study the source.
 - `:browse`  to find all of the definitions exported by a module
 - Use `:help` for the obvious result
 - use the web interface of [hoogle][1] to search for functions, or install hoogle locally!
 - ?
 - Profit!


  [1]: http://www.haskell.org/hoogle/

I have the following DateTime 4/25/2011 5:12:13 PM
and tried this to convert it to int

     int result = dateDate.Year * 10000 + dateDate.Month * 100 
                 + dateDate.Day + dateDate.Hour + dateDate.Minute + dateDate.Second;

But it still getting 2011425 how can i get the time as well?

How can I convert a DateTime to an int?

I am wondering what the proper way is to delete a repository when using gitolite.

Is there anything else I have to do besides delete the repository from the server and remove all configurations related to the repository I am removing?

Deleting Git Repository Gitolite?

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?

<p>I'm using Haskell 2010.1.0.0.1 with GHC 6. Typing <code>:t</code> 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?</p>


If I&#39;m going to put a program into production, there are several things I need that program to do in order to consider it &quot;operationalized&quot; – that is, running and maintainable in a measurable and verifiable way by both engineers and operations staff. For my purposes, an operationalized program must:

 - Be able to log at multiple levels (ex: debug, warning, etc.).
 - Be able to collect and share metrics/statistics about the types of work the program is doing and how long that work is taking. Ideally, the collected metrics are available in a format that&#39;s compatible with commonly-used monitoring tools like [Ganglia][1], or can be so munged.
 - Be configurable, ideally via a system that allows configured properties in running programs to be updated without restarting said programs.
 - Be deployable to remote servers in a repeatable way.

In the Scala world, there are good libraries for dealing with at least the first three requirements. Examples:

 - [Logula][2] for logging.
 - [Metrics][3] or [Ostrich][4] for collecting and reporting metrics.
 - [Configgy][5] or [Fig][6] for configuration.

As for deployment, one approach taken in the Scala world is to bundle together the bytecode and libraries that comprise one&#39;s program with something like [assembly-sbt](https://github.com/codahale/assembly-sbt), then push the resulting bundle (a &quot;fat JAR&quot;) to remote servers with a tool like [Capistrano](https://github.com/capistrano/capistrano) that executes commands in parallel over SSH. This isn&#39;t a problem that necessitates language-specific tools, but I&#39;m curious if such a tool exists in the Haskell community.

There are probably Haskell libraries that provide the traits I&#39;ve described above. I&#39;d like to know which of the available libraries are considered &quot;best&quot;; that is, which are most mature, well-maintained, commonly used in the Haskell community, and exemplary of Haskell best practices. 

If there are any other libraries, tools, or practices around making Haskell code &quot;production-ready&quot;, I&#39;d love to know about those as well.


  [1]: http://ganglia.sourceforge.net/
  [2]: https://github.com/codahale/logula
  [3]: https://github.com/codahale/metrics
  [4]: https://github.com/twitter/ostrich
  [5]: https://github.com/robey/configgy
  [6]: https://github.com/codahale/fig

What are the best Haskell libraries to operationalize a program?

Ordinary function composition is of the type

    (.) :: (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c

I figure this should generalize to types like:

    (.) :: (c -&gt; d) -&gt; (a -&gt; b -&gt; c) -&gt; a -&gt; b -&gt; d

A concrete example: calculating difference-squared.  We could write `diffsq a b = (a - b) ^ 2`, but *it feels like* I should be able to compose the `(-)` and `(^2)` to write something like `diffsq = (^2) . (-)`.

I can&#39;t, of course.  One thing I *can* do is use a tuple instead of two arguments to `(-)`, by transforming it with `uncurry`, but this isn&#39;t the same.

Is it possible to do what I want?  If not, what am I misunderstanding that makes me think it should be possible?

----

**Note:** This has effectively already been asked [here](https://stackoverflow.com/questions/4551419/generic-function-composition-in-haskell), but the answer (that I suspect must exist) was not given.

Haskell function composition operator of type (c→d) → (a→b→c) → (a→b→d)

I see `go` a lot when reading Haskell material or source, but I&#39;ve never been really comfortable about it - (I guess it has the negative connotation of &quot;goto&quot; in my mind). I started learning Haskell with LYAH, and that&#39;s where I picked up the tendency to use `acc` and `step` when writing folds. Where does the convention for writing `go` come from?

Most importantly, what exactly is the name `go` supposed to imply?

Haskell: why the convention to name a helper function &quot;go&quot;?

I&#39;ve been reading the &quot;Real World Haskell&quot; book, the chapter on concurrency and parallelism. My question is as follows:

- Since Haskell threads are really just multiple &quot;virtual&quot; threads inside one &quot;real&quot; OS-thread, does this mean that creating a lot of them (like 1000) will not have a drastic impact on performance? I.e., can we say that the overhead incurred from creating a Haskell thread with `forkIO` is (almost) negligible? Please bring pactical examples if possible.

- Doesn&#39;t the concept of lightweight threads prevent us from using the benefints of multicore architectures? As I understand, it is not possible for two Haskell threads to execute concurrently on two separate cores, because they are really one single thread from the operating system&#39;s point of view. Or does the Haskell runtime do some clever tricks to ensure that multiple CPU&#39;s can be made use of? 

Haskell lightweight threads overhead and use on multicores

I have twice recently refactored code in order to change the order of parameters because there was too much code where hacks like `flip` or `\x -&gt; foo bar x 42` were happening.

When designing a function signature what principles will help me to make the best use of currying? 

Ordering of parameters to make use of currying

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?

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

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

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?

Content Type	Original Author	Original Content on Stackoverflow
Question	franco hades	View Question on Stackoverflow
Solution 1 - Haskell	Don Stewart	View Answer on Stackoverflow
Solution 2 - Haskell	luqui	View Answer on Stackoverflow
Solution 3 - Haskell	Thomas M. DuBuisson	View Answer on Stackoverflow

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

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Solution 2 - Haskell

Solution 3 - Haskell

Deleting Git Repository Gitolite?

How can I convert a DateTime to an int?

Attributions