StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
8331995
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
4
CommunityOwnedDate
CreationDate
2011-11-30T19:47:29.063
FavoriteCount
0
LastActivityDate
2017-11-15T22:57:34.680
LastEditDate
2017-11-15T22:57:34.680
LastEditorUserId
791604
OwnerUserId
791604
ParentId
8327032
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
Alright, there's a lot of confusion about what's happening here floating around, and it's not being helped by the fact that the Haskell term "class" does not line up with the OO term "class" in any meaningful way. So let's try to make a careful answer. This answer starts with Haskell's module system. In Haskell, when you import a module <code>Foo.Bar</code>, it creates a new set of bindings. For each variable <code>x</code> exported by the module <code>Foo.Bar</code>, you get a new name <code>Foo.Bar.x</code>. In addition, you may: <ul> <li>import qualified or not. If you import qualified, nothing more happens. If you do not, an additional name without the module prefix is defined; in this case, just plain old <code>x</code> is defined.</li> <li>change the qualification prefix or not. If you import <code>as Alias</code>, then the name <code>Foo.Bar.x</code> is not defined, but the name <code>Alias.x</code> is.</li> <li>hide certain names. If you hide name <code>foo</code>, then neither the plain name <code>foo</code> nor any qualified name (like <code>Foo.Bar.foo</code> or <code>Alias.foo</code>) is defined.</li> </ul> Furthermore, names may be multiply defined. For example, if <code>Foo.Bar</code> and <code>Baz.Quux</code> both export the variable <code>x</code>, and I import both modules without qualification, then the name <code>x</code> refers to both <code>Foo.Bar.x</code> and <code>Baz.Quux.x</code>. If the name <code>x</code> is never used in the resulting module, this clash is ignored; otherwise, a compiler error asks you to provide more qualification. Finally, if none of your imports mention the module <code>Prelude</code>, the following implicit import is added: <pre><code>import Prelude </code></pre> This imports the <code>Prelude</code> without qualification, with no additional prefix, and without hiding any names. So it defines "bare" names and names prefixed by <code>Prelude.</code>, and nothing more. Here ends the bare basics you need to understand about the module system. Now let's discuss the bare basics you need to understand about typeclasses. A typeclass includes a class name, a list of type variables bound by that class, and a collection of variables with type signatures that refer to the bound variables. Here's an example: <pre><code>class Foo a where foo :: a -> a -> Int </code></pre> The class name is <code>Foo</code>, the bound type variable is <code>a</code>, and there is only one variable in the collection, namely <code>foo</code>, with type signature <code>a -> a -> Int</code>. This class declares that some types have a binary operation, named <code>foo</code>, which computes an <code>Int</code>. Any type may later (even in another module) be declared to be an instance of this class: this involves defining the binary operation above, where the bound type variable <code>a</code> is substituted with the type you are creating an instance for. As an example, we might implement this for integers by the instance: <pre><code>instance Foo Int where foo a b = (a `mod` 76) * (b + 7) </code></pre> Here ends the bare basics you need to understand about typeclasses. We may now answer your question. The only reason the question is tricky is because it falls smack dab on the intersection between two name management techniques: modules and typeclasses. Below I discuss what this means for your specific question. The module <code>Prelude</code> defines a typeclass named <code>Num</code>, which includes in its collection of variables a variable named <code>*</code>. Therefore, we have several options for the name <code>*</code>: <ul> <li>If the type signature we desire happens to follow the pattern <code>a -> a -> a</code>, for some type <code>a</code>, then we may implement the <code>Num</code> typeclass. We therefore extend the <code>Num</code> class with a new instance; the name <code>Prelude.*</code> and any aliases for this name are extended to work for the new type. For matrices, this would look like, for example, <pre><code>instance Num Matrix where m * n = {- implementation goes here -} </code></pre></li> <li>We may define a different name than <code>*</code>. <pre><code>m |*| n = {- implementation goes here -} </code></pre></li> <li>We may define the name <code>*</code>. Whether this name is defined as part of a new type class or not is immaterial. If we do nothing else, there will then be at least two definitions of <code>*</code>, namely, the one in the current module and the one implicitly imported from the <code>Prelude</code>. We have a variety of ways of dealing with this. The simplest is to explicitly import the <code>Prelude</code>, and ask for the name <code>*</code> not to be defined: <pre><code>import Prelude hiding ((*)) </code></pre> You might alternately choose to leave the implicit import of <code>Prelude</code>, and use a qualified <code>*</code> everywhere you use it. Other solutions are also possible.</li> </ul> The main point I want you to take away from this is: the name <code>*</code> is in no way special. It is just a name defined by the <code>Prelude</code>, and all of the tools we have available for namespace control are available.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWrite this Scala Matrix multiplication in Haskell
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USDaniel Wagner
UserOwnerUserId
1. USDaniel Wagner
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.