Haskell 定义列表和列表理解

Question

Good morning!

I am trying to define a list that takes in all possible Address types, which I have previously defined, and use list comprehension to do so.

Here's what I've got for earlier definitions that will likely be helpful for you to know:

data Row = A | B | C | D | E | F | G | H | I | J deriving (Enum, Ord, Show, Bounded, Eq, Read)
data Column = One | Two | Three | Four | Five | Six | Seven | Eight | Nine | Ten  deriving (Enum, Ord, Show, Bounded, Eq, Read)
data Address = Address Row Column deriving (Show, Read, Eq)
data Cell = Cell Address Bool deriving (Show, Read, Eq)

I'm not sure if I need to be using Cell in this solution, but perhaps.

This is my current solution, and I'm wondering if anyone has suggestions on improving it, or perhaps it's just completely wrong. Any guidance would be appreciated!

allAddressesA = [ x * y | x <- [Row] y <- [Column]]

And just for reference, here's a formal written requirement:

Define allAddressesA as the list of all possible board Addresses. Use a list comprehension that uses ranges of your Row and Column types.

Thank you! I'll be closely monitoring this so feel free to ask anything that you need clarified to help. I appreciate you taking the time to read this and potentially offer advice :)

Answer 1

You write:

This is my current solution, and I'm wondering if anyone has suggestions on improving it, or perhaps it's just completely wrong.

Whether it is completely wrong can be easily tested of course. Just type it in and ask your compiler:

allAddressesA = [ x * y | x <- [Row] y <- [Column]]

Mine says:

parse error on input `<-'

I guess that qualifies as wrong.

So, let us first fix the syntax. The possibly multiple clauses in the second part of a list comprehension (the part after the | , that is) are to be separated by commas. Doing so gives:

allAddressesA = [ x * y | x <- [Row], y <- [Column]]

What does the compiler think of that?

Not in scope: data constructor `Row'
Not in scope: data constructor `Column'

Indeed, Row and Column are type constructors rather than data constructors. That means that you can use them to build type expressions, but not to build "ordinary" value expressions.

Clearly, we are on the wrong path. So let us take a few steps back.

Both your Row type and your Column type are in the type classes Enum and Bounded . Hence, we can easily produce lists with all row and column designators, respectively:

allRows    = [minBound :: Row    .. maxBound]
allColumns = [minBound :: Column .. maxBound]

(Using minBound and maxBound makes your code somewhat more robust than immediately using A and J , and One and Ten , respectively, in the sense that adding constructors to Row and Column does not require you to change the definitions of allRows and allColumns .)

In an interactive environment we can easily evaluate these lists. Indeed, printing allRows gives:

> allRows
[A,B,C,D,E,F,G,H,I,J]

and for allColumns we get

> allColumns
[One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten]

Now, as an address consists of a row and a column designator, generating all possible addresses simply reduces to taking the cross product of all rows and all columns. With the previous definitions for allRows and allColumns in place, we can easily write such a cross product as a list comprehension:

allAddresses = [Address row column | row <- allRows, column <- allColumns]

As you have 10 row designators and 10 column designators, you end up with a list of 10 x 10 = 100 addresses:

> length allAddresses
100

For amusement's sake, let us print the first 15:

> take 15 allAddresses
[Address A One,Address A Two,Address A Three,Address A Four,Address A Five,
Address A Six,Address A Seven,Address A Eight,Address A Nine,Address A Ten,
Address B One,Address B Two,Address B Three,Address B Four,Address B Five]

Answer 2

Here's the skeleton for your code:

allAddressesA = [ Address {- ... -} | x <- [A .. J], y <- [ {- ... -} ]]

replace each {- ... -} with the correct code.

data Address = Address Row Column

means that you get to create compound data of type Address , by using a constructor function named Address , which expects two arguments: first of type Row , and second of type Column . In specifying ranges, we show data elements, not types or course: we write [1 .. 10] , not [Int] .