[Haskell-beginners] Program reliability and multiple data constructors; polymorphism

Markus Läll markus.l2ll at gmail.com
Wed Apr 18 18:51:45 CEST 2012

If you want type safety, then use different types (data Circle, data
Rectangle, ..) and implement the properties you want via classes, i.e
'class HasRadius a', 'class HasSomethingElse a' and some such. Right
now you only have one type, and wanting it to be type safe at that is,
khm ..impossible.

In general, for all of what you program you should have some specific
goal in mind, a concrete outcome. For the radius problem the solution
could also be (instead of having it as a class) of giving it the type
of 'Shape -> Maybe Float' and have it return 'Nothing' when radius
isn't applicable. When you just tinker away and try to solve all of 2D
geometry with it, or any part of it at random, usually leads to
nowhere (for me at least).


Just noticed the subject which says "polymorphism" at the end.

In Haskell you can have structural polymorphism, like 'data X a = X a'
where 'X a' is polymorphic at 'a' -- you can have any type at the
place of 'a'. Or or ad hoc polymorphism -- the thing that classes do.
The Shape data type in the initial post is monomorphic and recursive.

On Wed, Apr 18, 2012 at 7:14 PM, umptious <umptious at gmail.com> wrote:
> Re. my previous post below, I'm guessing that the most elegant solution to
> the problem of how to get the program to work is to hide all the cstrs and
> only let access be through functions using record syntax like this Haskell
> wiki example:
> data Foo2 = Bar2 | Baz2 {barNumber::Int, barName::String}
> --Using records allows doing matching and binding only for the variables
> relevant to the function we're writing, making code much clearer:
> h :: Foo2 -> Int
> h Baz2 {barName=name} = length name
> h Bar2 {} = 0
> --Also, the {} pattern can be used for matching a constructor regardless of
> the datatype elements even if you don't use records in the data declaration:
> data Foo = Bar | Baz Int
> g :: Foo -> Bool
> g Bar {} = True
> g Baz {} = False
> main = do
>   print $ h a
>   print $ h b
>   where
>     a = Bar2
>     b = Baz2{barNumber=1, barName="fredikins"}
> ...Is this correct? And if so, is the answer to my second question "There's
> no way of getting the compiler to guarantee runtime safety, so when you have
> record syntax ctsrs for the same type which create objects with different
> data, hide the ctsrs"?
> On 18 April 2012 16:10, umptious <umptious at gmail.com> wrote:
>> One of the programming exercises I keep evolving as I learn Haskell is a
>> toy 2D shape editor with four primitives:
>> data Shape =   Circle   {origin::Pt2, radius::Float}
>>                        | Square   {origin::Pt2, side  ::Float}
>>                        | Rect     {origin::Pt2, other ::Pt2}
>>                        | Composite {shapes::[Shape]}
>>                          deriving (Show, Read)
>> The intent  is Composites can contain Shapes of any kind, including other
>> Composites so that you can apply transformations to a Composite and these
>> will be applied to the contained Shapes recursively. So an arm might contain
>> a hand which constains a dozen or so Rects. Transform the arm and the hand
>> and rects should transform; transform the hand and its rects should
>> transform but the not arm. Big deal.
>> And the above makes that really easy when you know you're talking to a
>> Composite. But now I've hit an intellectual stumbling point and the books
>> and source I have don't seem to address it:  I can apply the destructuring
>> command "shapes" defined in the cstr "Composite" to ANY Shape. And if I do
>> that to say a circle, BLAM! Or if I apply "radius" to Rect, BLAM! At
>> runtime. No type checking support (because yes, they're the same type.)
>> To me this seems alarming. It means that I can't reason about the safety
>> of my program based on type checking as I'd like. And none of the answers I
>> can think seem at all elegant:
>> - I could use exception handling, but that means carefully checking which
>> data declarations are potential bombs and using exceptions only when they
>> are involved - hideously error prone - or using exceptions everywhere. Which
>> is just hideous.
>> - I could hack run time type checking using the ctsr info in "show". But
>> again I'd have to know when to use it or use it everywhere. And it seems
>> like a ridiculous kludge to bring to a language that has been designed for
>> elegance.
>> ..So what is the Haskell idiom for dealing with this??? In fact I suppose
>> I'm asking two questions:
>> 1. How do I re-design this program so it is safe (use class and instance
>> maybe, abandoning use of a single data type? but I then have to have
>> separate Lists for each type, even if they derived from a common class?)
>> 2. How can one use compile time checking or (less good) coding practices
>> to eliminate the possibilty of such runtime exceptions?
>> And come to think of it
>> 3. is there a Haskell book which addresses design and structural problems
>> like this one - which I would have thought was both obvious and fundamental
>> - because of the books I've looked at so far seem to do a tolerable job. The
>> best of them present an adequate "on rails" tour, but none of them seem to
>> give you the tools to address issues like this one. Whereas with C++and
>> Stroustrupp, Common Lisp and Graham, the Smalltalk book, and I Erlang and
>> Armstrong I'd know exactly what to do. Admittedly the C++ solutions wouldn't
>> be pretty, but anything the compiled would be safe to run (unless I went to
>> great efforts otherwise..)
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners

Markus Läll

More information about the Beginners mailing list