Comment by TylerE

14 years ago

But that is I think OP's point, Haskell forces you to "model", versus something like scheme or python where you can just sling dicts around.

Haskell absolutely forces you to do a non-trivial amount of thinking up front, which is counter-productive when you're trying to throw something together in 10 minutes.

10 comments

TylerE

DanWaterworth 14 years ago

You can sling dicts around in Haskell too if you want to. The reason people don't is that the alternative is easier.

jneen 14 years ago

+100. That's one of the things I love about Haskell - it makes the "right" things easy and the "wrong" things hard.
stcredzero 14 years ago

You can sling dicts around in Haskell too if you want to. The reason people don't is that the alternative is easier.
This is extraordinary if it is true -- it would mean something in Haskell has succeeded in making the designed/intended "right way" in a programming language the "easy way."
I'm not so sure finding the right way to design a language/environment is right for a sole design focus anymore. A programming language/environment should be designed to unify and leverage the power of a community, in a way that elevates it above the level of "pop culture." (Where a pop culture is defined as one where the rate of change far outstrips the growth of actual value/knowledge.)

TylerE 14 years ago

But, if I remember correctly, the haskell map is typed, isn't it?

In python you can mix the types of both keys and values in a single dict freely.

jrockway 14 years ago

You can easily define your own type that is "everything". But how useful is a dict in python with keys and values of varying types? I've certainly never used one.

3 replies →

DanWaterworth 14 years ago

It's possible in Haskell:

  {-# LANGUAGE ExistentialQuantification #-}

  import Data.Maybe
  import Data.Typeable
  import Data.Dynamic

  import Data.Map (Map)
  import qualified Data.Map as M

  data Orderable = forall a. (Ord a, Typeable a) => Orderable a

  instance Eq Orderable where
    (Orderable a) == (Orderable b) =
      case cast b of
        Just b' -> a == b'
        Nothing -> False

  instance Ord Orderable where
    (Orderable a) < (Orderable b) =
      case typeOf a `compare` typeOf b of
        GT -> False
        LT -> True
        EQ -> a == fromJust (cast b)
    a > b = b < a
    a <= b = not (a > b)
    a >= b = not (a < b)

  toOrd :: (Ord a, Typeable a) => a -> Orderable
  toOrd = Orderable

  fromOrd :: (Ord a, Typeable a) => Orderable -> Maybe a
  fromOrd (Orderable a) = cast a

  m1 = M.empty
  m2 = M.insert (toOrd "hello world") (toDyn (4 :: Int)) m1
  m3 = M.insert (toOrd True) (toDyn "foo") m2
  m4 = M.insert (toOrd (5 :: Int)) (toDyn False) m3

  main = print ((fromJust (fromDynamic (fromJust (M.lookup (toOrd "hello world") m4)))) :: Int)