[Haskell-cafe] Re: Field names
(...) * Since a data constructor can be an infix operator (either spelled with backticks or a symbolic name beginning with ':' ) we can also write our patterns with infix notation. (...) (Slightly off-topic?) Do you have any reference for that use of infixing constructors by start their name with ':'? That's interesting, and I didn't know about it. Thanks, Maurício ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
Hello Mauricio, Wednesday, September 10, 2008, 4:07:41 PM, you wrote: Do you have any reference for that use of infixing constructors by start their name with ':'? That's interesting, and I didn't know about it. really? ;) sum (x:xs) = x + sum xs sum [] = 0 -- Best regards, Bulatmailto:[EMAIL PROTECTED] ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
On 2008 Sep 10, at 8:53, Bulat Ziganshin wrote: Wednesday, September 10, 2008, 4:07:41 PM, you wrote: Do you have any reference for that use of infixing constructors by start their name with ':'? That's interesting, and I didn't know about it. really? ;) sum (x:xs) = x + sum xs sum [] = 0 I think that only counts as the origin of the idea; isn't :-prefixed infix constructors a ghc-ism? http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#infix-tycons -- brandon s. allbery [solaris,freebsd,perl,pugs,haskell] [EMAIL PROTECTED] system administrator [openafs,heimdal,too many hats] [EMAIL PROTECTED] electrical and computer engineering, carnegie mellon universityKF8NH ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
On Wed, 2008-09-10 at 11:54 -0400, Brandon S. Allbery KF8NH wrote: On 2008 Sep 10, at 8:53, Bulat Ziganshin wrote: Wednesday, September 10, 2008, 4:07:41 PM, you wrote: Do you have any reference for that use of infixing constructors by start their name with ':'? That's interesting, and I didn't know about it. really? ;) sum (x:xs) = x + sum xs sum [] = 0 I think that only counts as the origin of the idea; isn't :-prefixed infix constructors a ghc-ism? http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#infix-tycons That link is for type constructors, not data constructors; for data constructors, go to http://haskell.org/onlinereport/lexemes.html and search for `Operator symbols'. (The Haskell 98 Report seems to not have internal anchor tags for hot-linking, unfortunately). jcc ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
[Haskell-cafe] Re: Field names
Do you have any reference for that use of infixing constructors by start their name with ':'? (...) (...) for data constructors, go to http://haskell.org/onlinereport/lexemes.html and search for `Operator symbols'. (...) Here it is: “Operator symbols are formed from one or more symbol characters, as defined above, and are lexically distinguished into two namespaces (Section 1.4): * An operator symbol starting with a colon is a constructor.(...)” Cool! What is the syntax for using that in 'data'? Is it something like “data X = Y | Int :° Double”? Maurício ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
On 11 Sep 2008, at 3:54 am, Brandon S. Allbery KF8NH wrote: I think that only counts as the origin of the idea; isn't :-prefixed infix constructors a ghc-ism? Haskell 98 report, page 10: An operator symbol starting with a colon is a constructor. (I seem to have four copies of the report on my Mac...) ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
On Wed, 2008-09-10 at 21:32 -0300, Mauricio wrote: Do you have any reference for that use of infixing constructors by start their name with ':'? (...) (...) for data constructors, go to http://haskell.org/onlinereport/lexemes.html and search for `Operator symbols'. (...) Here it is: “Operator symbols are formed from one or more symbol characters, as defined above, and are lexically distinguished into two namespaces (Section 1.4): * An operator symbol starting with a colon is a constructor.(...)” Cool! What is the syntax for using that in 'data'? Is it something like “data X = Y | Int :° Double”? Right. So then (:°) :: Int - Double - X jcc ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
2008/9/8 Daryoush Mehrtash [EMAIL PROTECTED] Thanks. Pattern matching and memory management in Haskell (or may be GHC implementation of it) is somewhat of a mystery to me. Are there any references that explains the underlying implementation? Daryoush Be careful what you ask for. This paper is 16 years old but fairly relevant. Click the view or download link at the bottom: Implementing Lazy Functional Languages on Stock Hardware: The Spineless Tagless G-Machine http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.53.3729 Justin ___ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
Justin Bailey wrote:
2008/9/8 Daryoush Mehrtash [EMAIL PROTECTED]
Thanks.
Pattern matching and memory management in Haskell (or may be GHC
implementation of it) is somewhat of a mystery to me. Are there
any references that explains the underlying implementation?
Be careful what you ask for. This paper is 16 years old but fairly
relevant. Click the view or download link at the bottom:
Implementing Lazy Functional Languages on Stock Hardware: The
Spineless Tagless G-Machine
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.53.3729
That's an excellent paper for getting down to the gritty details of
what's going on under the covers. However, I think it's not clear that
that's what you're really looking for; you needn't know anything about
the STG in order to know how pattern matching works enough to use it.
In short, a pattern is a (free) variable, or a data constructor applied
to patterns. So if we have:
data MyList = Nil | Cons Int MyList
Then we can have the patterns: Nil, (Cons x xs), (Cons 0 xs),..., (Cons
x Nil), (Cons 0 Nil),..., (Cons x (Cons x2 xs)), etc.
Other notes:
* As demonstrated above, numeric literals count as data constructors.
* Since a data constructor can be an infix operator (either spelled with
backticks or a symbolic name beginning with ':' ) we can also write our
patterns with infix notation.
* Even though there is an intentional homoiconicity between patterns and
an expression of data constructors, you can't use arbitrary expressions.
This falls out from only allowing data constructors in patterns,
rather than any arbitrary function.
** In particular, you can't use partial application. You also can't use
anything like (.), ($), flip,...
** (While n+k patterns exist for legacy reasons, they are an
abomination. They should not be used and are slated for removal in
haskell prime.)
** For record syntax this homoiconicity means that you get Foo{xpart=x}
as a pattern binding the variable x. This follows because that's what
the expression would look like to construct a Foo setting the xpart to a
variable x. Perhaps confusingly, the '=' involved here is the one from
record syntax, not the one from let bindings.
The homoiconicity generally makes code easier to read, though it can be
somewhat confusing when discussing theoretical concerns. The reason is
that a single lexeme, e.g. 'Cons', is being used both as a data
constructor (in expressions) and as a data *de*structor (in patterns).
Identically, a field name in a record is used both as an injector and as
a projector. This conceptual overloading is perfectly valid, but it
sometimes leads to people conflating the ideas which is invalid.
There are sometimes reasons to want to throw a wrench into the works,
breaking up the homoiconicity. One particular example (which I believe
will be available in 6.10 though it's not approved for haskell prime) is
to allow view patterns. The idea behind view patterns is to allow
functions to be called behind the scenes in order to convert the
in-memory representation into a view type, and then do pattern matching
on that view of the value rather than on the value itself. There are two
primary uses of this: (1) improving legibility of pattern matching for
complex datastructures, (2) allowing multiple types to all be pattern
matched interchangeably, e.g. association lists, Maps, HashMaps,...
There are drawbacks to views (and anything else that breaks
homoiconicity). First off is that it greatly complicates the story of
what's going on during pattern matching. More importantly, however, is
that it means that pattern matches are no longer in correspondence with
the in-memory representations of values. This means that there is a
hidden performance cost which can get quite high for deep patterns.
--
Live well,
~wren
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
[Haskell-cafe] Re: Field names
abs (Pt {pointx = x, pointy = y}) = sqrt (x*x + y+y)
Why is it pointx=x and not x=pointx?
Your intuition is probably telling you that this
is something like:
abs (point) = sqrt (x*x+y*y)
where {x=pointx point ; y=pointy point}
Actually, it's an example of pattern matching:
abs (Pt {pointx=3 , pointy=4}) = 5
abs (Pt {pointx=3 , pointy=y}) = sqrt (9+y*y)
abs (Pt {pointx=z , pointy=z}) = (sqrt 2)*z
etc.
Best,
Maurício
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Re: [Haskell-cafe] Re: Field names
Thanks.
Pattern matching and memory management in Haskell (or may be GHC
implementation of it) is somewhat of a mystery to me. Are there any
references that explains the underlying implementation?
Daryoush
On Mon, Sep 8, 2008 at 6:37 PM, Mauricio [EMAIL PROTECTED] wrote:
abs (Pt {pointx = x, pointy = y}) = sqrt (x*x + y+y)
Why is it pointx=x and not x=pointx?
Your intuition is probably telling you that this
is something like:
abs (point) = sqrt (x*x+y*y)
where {x=pointx point ; y=pointy point}
Actually, it's an example of pattern matching:
abs (Pt {pointx=3 , pointy=4}) = 5
abs (Pt {pointx=3 , pointy=y}) = sqrt (9+y*y)
abs (Pt {pointx=z , pointy=z}) = (sqrt 2)*z
etc.
Best,
Maurício
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
--
Daryoush
Weblog: http://perlustration.blogspot.com/
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
