What does (..) mean?

Question

I'm trying to learn Haskell.

I'm reading the code on here[1]. I just copy and past some part of the code from lines:46 and 298-300.

Question: What does (..) mean?

I Hoggled it but I got no result.

module Pos.Core.Types(
-- something here

 SharedSeed (..) -- what does this mean?

) where


newtype SharedSeed = SharedSeed
{ getSharedSeed :: ByteString
} deriving (Show, Eq, Ord, Generic, NFData, Typeable)

[1] https://github.com/input-output-hk/cardano-sl/blob/master/core/Pos/Core/Types.hs

[Relevant answer](https://stackoverflow.com/a/13481892/752976) — Bartek Banachewicz, Aug 02 '17 at 11:54
For anybody else landing on this question via the search engine: `..` also has *another*, unrelated meaning in lists: `[1..5]`. Here it's syntax sugar for `enumFromTo`. You can probably find out about this if you search for "list comprehensions". — MathematicalOrchid, Aug 02 '17 at 12:54
Not just `enumFromTo`: that whole family of Enum functions have shorthand notations using `..` in different ways. — amalloy, Aug 02 '17 at 17:16

score 5 · Answer 1 · edited Aug 02 '17 at 15:22

5

It means "export all constructors and record fields for this data type".

When writing a module export list, there's three⁴ ways you can export a data type:

module ModuleD(
    D,       -- just the type, no constructors
    D(..),   -- the type and all its constructors
    D(DA)    -- the type and the specific constructor
    ) where

data D = DA A | DB B

If you don't export any constructors, the type, well, can't be constructed, at least directly. This is useful if you e.g. want to enforce some runtime invariants on the data type:

module Even (evenInt, toInt) where

newtype EvenInt = EvenInt Int deriving (Show, Eq)

evenInt :: Int -> Maybe EvenInt
evenInt x = if x `mod` 2 == 0 then Just x else Nothing

toInt :: EvenInt -> Int
toInt (EvenInt x) = x

The caller code can now use this type, but only in the allowed manner:

x = evenInt 2
putStrLn $ if isJust x then show . toInt . fromJust $ x else "Not even!"

As a side note, toInt is usually implemented indirectly via the record syntax for convenience:

data EvenInt = EvenInt { toInt :: Int }

⁴ See @leftaroundabout's answer

edited Aug 02 '17 at 15:22

Jon Purdy

53,300
8
96
166

answered Aug 02 '17 at 11:53

Bartek Banachewicz

38,596
7
91
135

Thanks for the answer, what if we don't use it? – user153438 Aug 02 '17 at 11:54
@user153438 Then only the type itself is exported, but users can't see the constructors. It's an abstract type. – melpomene Aug 02 '17 at 11:58
@melpomene thanks. Am I right it can still use the constructor? – user153438 Aug 02 '17 at 12:00
@user153438 I've added an example, hope it clarifies things a bit. – Bartek Banachewicz Aug 02 '17 at 12:02
3

_export all constructors for this data type_ ← not only constructors, record fields as well. – Shersh Aug 02 '17 at 12:08
In general, you should either export *all* the constructors or *none* of them. The same syntax is used for class methods. It can make sense to (re-)export only some class methods. – dfeuer Aug 02 '17 at 17:11

score 5 · Answer 2 · edited Aug 02 '17 at 12:30

The syntax of import/export lists has not much to do with the syntax of Haskell itself. It's just a comma-separated listing of everything you want to export from your module. Now, there's a problem there because Haskell really has two languages with symbols that may have the same name. This is particularly common with newtypes like the one in your example: you have a type-level name SharedSeed :: *, and also a value-level name (data constructor) SharedSeed :: ByteString -> SharedSeed.

This only happens with uppercase names, because lowercase at type level are always local type variables. Thus the convention in export lists that uppercase names refer to types.

But just exporting the type does not allow users to actually construct values of that type. That's often prudent: not all internal-representation values might make legal values of the newtype (see Bartek's example), so then it's better to only export a safe smart constructor instead of the unsafe data constructor.

But other times, you do want to make the data constructor available, certainly for multi-constructor types like Maybe. To that end, export lists have three syntaxes you can use:

module Pos.Core.Types(

SharedSeed (SharedSeed) will export the constructor SharedSeed. In this case that's of course the only constructor anyway, but if there were other constructors they would not be exported with this syntax.
SharedSeed (..) will export all constructors. Again, in this case that's only SharedSeed, but for e.g. Maybe it would export both Nothing and Just.
pattern SharedSeed will export ShareSeed as a standalone pattern (independent of the export of the ShareSeed type). This requires the -XPatternSynonyms extension.
```
)
```

What does (..) mean?

2 Answers2