News for hackers. Stuff that matters.
Re:Translating Haskell to C++ metaprogramming by oever on Sunday July 12, 2015 @06:32PM (#9875292)
I use the term 'metaprogramming' because that's the title of the relevant chapter in Stroustrups 'The C++ programming language'. I do think that 'C++ metaprogamming' is a bit clunky, but 'C++ template programming' sounds too limited. 'compile time programming' also sounds strange.

Wikipedia says: "Metaprogramming is the writing of computer programs with the ability to treat programs as their data." Writing C++ templates to treat Relax NG specifications and literal XML in C++ as input for schema validation would fit that definition.

Re:Translating Haskell to C++ metaprogramming by igravious on Sunday July 12, 2015 @09:37PM (#9875891)
I think 'C++ template programming' might be better also :/

The following syntax in Haskell causes a parse error in my brain:

    contains :: NameClass -> QName -> Bool
I really want it to be

    contains :: (NameClass, QName) -> Bool
Or even just

    contains :: NameClass, QName -> Bool
Is it just my problem to get over or do other people have it, or is there syntactic sugar coming to my rescue?
Re:Translating Haskell to C++ metaprogramming by gizmo686 on Sunday July 12, 2015 @10:09PM (#9875981)

    contains :: (NameClass, QName) -> Bool
is valid Haskel, and denotes that "contains" is a function that takes a tuple and returns a bool. As a matter of style, Haskellers tend to avoid writing function like this, and prefer to write functions like

    contains :: NameClass -> (QName -> Bool)
which indicates that "contains" is a function that takes a "NameClass" and returns another function. Because this pattern is so common in Haskell, -> is defined to be right-associative, so the paranthese can be omited.
Re:Translating Haskell to C++ metaprogramming by gaze on Sunday July 12, 2015 @09:40PM (#9875900)
You should get over it. It's just syntax... and it's there for a reason (Makes more sense for curried functions, and it's a holdover from logic where you say that if you have a nameclass, you have an object that sense a qname to a bool, and if you have a nameclass and a qname then you have a bool.)
Re:Translating Haskell to C++ metaprogramming by igravious on Sunday July 12, 2015 @09:56PM (#9875948)
What? Are you saying that I can legitimately read

    contains :: NameClass -> QName -> Bool
two ways? Like,

    contains :: (NameClass, QName) -> Bool
And

    contains :: NameClass -> (QName, Bool)
? What about four types?

    contains :: Urk -> NameClass -> QName -> Bool
Re:Translating Haskell to C++ metaprogramming by kenko on Monday July 13, 2015 @12:33AM (#9876414)
No, a -> b -> c always means a -> (b -> c).

a -> b -> c -> d always means a -> (b -> (c -> d)).

"->" is right-associative.

Re:Translating Haskell to C++ metaprogramming by gaze on Monday July 13, 2015 @09:18AM (#9877885)
You should first understand currying. If I have a function f :: A -> B -> C -> D, every time I apply an argument, as in f a where a is of type A (b :: B, c :: C, ...), you get a new function back of type B -> C -> D. Read :: as "has type." Therefore

f :: A -> B -> C -> D

f a :: B -> C -> D

f a b :: C -> D

f a b c :: D

This is why Haskell's function call syntax seems a bit funny, and the typing syntax (->) seems funny. Every time you apply an argument you get a new object back which represents the result of applying the function. Once you've applied everything to the left of the rightmost type, you have the result.

It's a statement of implication. If I have an a and an f, the most I can have is a function which takes arguments of type B, C, and D, and so forth.

Re:Translating Haskell to C++ metaprogramming by Nullabillity on Sunday July 12, 2015 @10:03PM (#9875967)
Not quite. It's equivalent to either

    contains :: (NameClass, QName) -> Bool
or

    contains :: NameClass -> (QName -> Bool)
In other words, you can treat it as a function taking two arguments, or one function taking one argument and returning another function.
Re:Translating Haskell to C++ metaprogramming by theseoafs on Sunday July 12, 2015 @10:29PM (#9876041)
It is equivalent to the second, not the first. The first is a completely distinct type -- though you can certainly write a function with that type, given the original function, by uncurrying it.
Re:Translating Haskell to C++ metaprogramming by saurik on Monday July 13, 2015 @01:13AM (#9876540)
FWIW, I think the person you are responding to is using the non-Haskell requested mental syntax used by the person who asked the original question, in order so they better understand the semantics (even if at a cost of confusing them for later development in Haskell).
Re:Translating Haskell to C++ metaprogramming by Nullabillity on Monday July 13, 2015 @06:11AM (#9877207)
Yup. They're distinct types, but mentally they are the same (and the standard library has functions to convert between the two forms).