Haskell GHCI ne charge pas le fichier objet compilé

Question

Je voudrais que GHCI charge le code objet compilé d'un module qui, une fois compilé, est nettement plus rapide que la version non compilée. Cela fonctionnait bien lorsque tous les fichiers se trouvaient dans le même répertoire (pas de hiérarchie de modules). Cependant, elles ne fonctionnent pas lorsque les fichiers sont dans des hiérarchies de modules.

Version de travail MyFile.hs :

import Basic
import Histogram

où Basic.o et Histogram.o sont dans le même répertoire que MyFile.hs

Version non fonctionnelle MyFile.hs :

import Util.Basic
import Util.Histogram

où Basic.o et Histogram.o sont dans un sous-répertoire Util. Avec cette version, j'obtiens le résultat suivant lors du chargement de MyFile.hs :

[1 of 2] Compiling Util.Basic ( Util/Basic.hs, interpreted )
[2 of 2] Compiling Util.Histogram ( Util/Histogram.hs, interpreted )
Ok, modules loaded: Util.Basic, Util.Histogram.

J'aimerais pouvoir organiser mon code en modules tout en bénéficiant des avantages de l'utilisation des fichiers o compilés.

Il convient également de noter que les fichiers sources n'ont pas été modifiés depuis la compilation des fichiers o.

Edits : Voici le contenu de chaque fichier :

MonFichier.hs

import Util.Basic
import Util.Histogram

Util/Basic.hs

module Util.Basic () where

Util/Histogramme.hs

module Util.Histogram () where

Fichiers / Compilation :

$:~/programming/haskell/example-error$ ls
MyFile.hs  MyFile.hs~  Util
$:~/programming/haskell/example-error$ cd Util
$:~/programming/haskell/example-error/Util$ ls
Basic.hs  Basic.hs~  Histogram.hs  Histogram.hs~
$:~/programming/haskell/example-error/Util$ ghc *.hs
[1 of 2] Compiling Util.Histogram   ( Histogram.hs, Histogram.o )
[2 of 2] Compiling Util.Basic       ( Basic.hs, Basic.o )
$:~/programming/haskell/example-error/Util$ ls
Basic.hi  Basic.hs~  Histogram.hi  Histogram.hs~
Basic.hs  Basic.o    Histogram.hs  Histogram.o
$:~/programming/haskell/example-error/Util$  cd ../
$:~/programming/haskell/example-error$ ghci -ignore-dot-ghci MyFile.hs
GHCi, version 7.4.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 3] Compiling Util.Histogram   ( Util/Histogram.hs, interpreted )
[2 of 3] Compiling Util.Basic       ( Util/Basic.hs, interpreted )
[3 of 3] Compiling Main             ( MyFile.hs, interpreted )
Ok, modules loaded: Util.Basic, Util.Histogram, Main.
*Main> 

La solution qui a fonctionné comme suggéré par Daniel :

The fix is to compile the importing file, and the files in the 
subdirectory only as a consequence of that, not directly.

Answer 1

Le problème est le même que celui abordé ci-dessous, les drapeaux ont changé :

~/.../Util> ghc Other.hs
[1 of 1] Compiling Util.Other       ( Other.hs, Other.o )
~/.../Util> cd ..
~/.../src> ghc MyFile.hs
[1 of 2] Compiling Util.Other       ( Util/Other.hs, Util/Other.o ) [flags changed]
[2 of 2] Compiling MyFile           ( MyFile.hs, MyFile.o )

Je n'ai pas trouvé quels drapeaux en particulier, ou pourquoi les drapeaux passés lors de la compilation séparée sont différents de ceux qui sont passés lors de la compilation en tant que module chassé du module d'importation, mais ils changent, et donc une recompilation est nécessaire (Spécifiquement, la valeur du flag-hash dans le fichier .hi modifications de fichiers).

La solution consiste donc à ne pas compiler les modules séparément, mais à les compiler en tant que dépendances de l'importateur de premier niveau.

---

Supposition originale presque correcte :

Je ne peux le reproduire que partiellement. Après avoir compilé et ensuite touch ing MyFile.hs ,

$ ghci-7.4.2 MyFile.hs
-- snip
[1 of 2] Compiling Util.Other       ( Util/Other.hs, interpreted )
[2 of 2] Compiling MyFile           ( MyFile.hs, interpreted )
Ok, modules loaded: MyFile, Util.Other.

il semble que ce soit la même chose que pour vous, mais avec la 7.6.1, nous avons un indice (compilation et touch ) :

$ ghci MyFile.hs
-- snip
[1 of 2] Compiling Util.Other       ( Util/Other.hs, interpreted ) [flags changed]
[2 of 2] Compiling MyFile           ( MyFile.hs, interpreted )
Ok, modules loaded: MyFile, Util.Other.

Les drapeaux ont changé. J'ai :set -XNoMonomorphismRestriction dans mon .ghci et le changement de drapeaux provoque la recompilation.

$ ghci -ignore-dot-ghci MyFile.hs
GHCi, version 7.6.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[2 of 2] Compiling MyFile           ( MyFile.hs, interpreted )
Ok, modules loaded: MyFile, Util.Other.

Ignorer l'offense .ghci avec le drapeau qui n'a pas été donné pour la compilation, le inchangé Util.Other n'est pas interprété, le code compilé est utilisé. (Avec GHC < 7.4, le fait d'ignorer la balise .ghci n'est même pas nécessaire).

Si vous avez un .ghci dans lequel vous définissez les options de langue ( NoMonomorphismRestriction , TypeFamilies , ...) et ghc >= 7.4, vous devez ignorer l'élément .ghci lors du chargement des modules.

Si ce n'est pas le cas, la recompilation n'est pas le comportement attendu. Dans ce cas, de plus amples informations seraient nécessaires pour diagnostiquer le problème et trouver une solution.

Une solution de contournement partielle serait alors la suivante -fobject-code drapeau pour ghci.