Haskell "import qualified" and "Not in scope: data constructor" - haskell

Question

I have an import like this:
import qualified Bioinformatics.DNA as DNA
from an other file looking like this:
data DNA = A | C | G | T
deriving (Eq, Ord, Show)
And in this function in the module RNA where:
module Bioinformatics.RNA
( RNA
, fromDna
) where
import qualified Bioinformatics.DNA as DNA
data RNA = A | C | G | U
deriving (Eq, Ord, Show)
fromDna :: DNA.DNA -> RNA
fromDna DNA.A = A
fromDna DNA.C = C
fromDna DNA.G = G
fromDna DNA.T = U
I receive errors:
/home/thibaud/code/bioinformatics/src/Bioinformatics/RNA.hs:46:9:
Not in scope: data constructor ‘DNA.A’
/home/thibaud/code/bioinformatics/src/Bioinformatics/RNA.hs:47:9:
Not in scope: data constructor ‘DNA.C’
/home/thibaud/code/bioinformatics/src/Bioinformatics/RNA.hs:48:9:
Not in scope: data constructor ‘DNA.G’
/home/thibaud/code/bioinformatics/src/Bioinformatics/RNA.hs:49:9:
Not in scope: data constructor ‘DNA.T’
Do you have an idea why?
Thanks

Answer 1

Use (..) to import all the constructors of a data type.
import qualified Bioinformatics.DNA as DNA (DNA(..), A, C, G, T)
Code Breakdown
EDIT: Let's break down your code a little since its not quite idiomatic.
import qualified Bioinformatics.DNA as DNA (DNA(..), A, C, G, T)
That's already an odd one. Typically people import things qualified or selectively, not both. Try just:
import qualified Bioinfomatics.DNA as DNA
So lets keep the quantification and drop the explicit list of symbols.
Now for the use, you have:
fromDna :: DNA.DNA -> RNA
fromDna DNA.A = A
fromDna DNA.C = C
fromDna DNA.G = G
fromDna DNA.T = U
The claim that this function converts from DNA to RNA. Note your questino never presented an RNA type or constructors - are those in your code somewhere? The remaining error from the code you posted is with respect to RNA, consider something like:
import qualified Bioinformatics.RNA as RNA
fromDna :: DNA.DNA -> RNA.RNA
fromDna DNA.A = RNA.A
fromDna DNA.C = RNA.C
fromDna DNA.G = RNA.G
fromDna DNA.T = RNA.U

Answer 2

Let's imagine we need a Geometry.Shape module for operations on a shapes. First, we'll make a folder called Geometry. Mind the capital G. In it, we'll place the Shape.hs file. Here's what the file will contain:
module Geometry.Shape
( Shape(Circle,Rectangle)
, Point
) where
data Point = Point Float Float deriving (Show)
data Shape = Circle Point Float | Rectangle Point Point deriving (Show)
Notice that when defining a point, we used the same name for the data type and the value constructor.
So let's assume that we need the Geometry module for various geometric calculations. We will create the Geometry.hs file and place it at the same level as the Geometry directory:
module Geometry (area) where
import qualified Geometry.Shape as Shape
area :: Shape.Shape -> Float
area (Shape.Circle _ r) = pi * r ^ 2
area (Shape.Rectangle (Shape.Point x1 y1) (Shape.Point x2 y2)) =
(abs $ x2 - x1) * (abs $ y2 - y1)
The file structure should now look like this:
.
├── Geometry
│   └── Shape.hs
└── Geometry.hs
Well, let's check our area function. First we need to open GHCi in the same directory as the Geometry.hs file.
$ ghci
GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help
Prelude>
Then let's load Geometry module:
Prelude> :l Geometry.hs
[1 of 2] Compiling Geometry.Shape ( Geometry/Shape.hs, interpreted )
[2 of 2] Compiling Geometry ( Geometry.hs, interpreted )
Geometry.hs:7:24: Not in scope: data constructor ‘Shape.Point’
Geometry.hs:7:44: Not in scope: data constructor ‘Shape.Point’
Failed, modules loaded: Geometry.Shape.
Oops! Something went wrong. But wait! Look again at the error message:
Not in scope: data constructor ‘Shape.Point’
Well, simply speaking, it means that the type constructor is not in the reachable scope. So let's fix it by changing the Shape.hs file as follows:
module Geometry.Shape
( Shape(Circle,Rectangle)
, Point(..)
) where
Notice we changed Point to Point(..). Reload module as follows:
Prelude> :r
[1 of 2] Compiling Geometry.Shape ( Geometry/Shape.hs, interpreted )
[2 of 2] Compiling Geometry ( Geometry.hs, interpreted )
Ok, modules loaded: Geometry, Geometry.Shape.
and test it:
Prelude> area (Shape.Circle (Shape.Point 0 0) 24)
1809.5574
Yay, it works! I want to draw your attention to the fact that we used (..) to import all the constructors of the Point data type. It's the same as writing Point (Point). Similarly, we could use Shape(..) instead of Shape(Circle,Rectangle). For more see: https://www.haskell.org/tutorial/modules.html
Not exporting the value constructors of a data types makes them more abstract in such a way that we hide their implementation. Also, whoever uses our module can't pattern match against the value constructors. This is why previously we get compilation error in the Geometry module.
I hope this example will help you understand the reason for such errors.