Comment by 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.

9 comments

DanWaterworth

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

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.
- TylerE 14 years ago
  
  It's very useful.
  Use it like you'd use a bare object in Javascript, as a freeform data container to hold whatever properties you need. A bit like a key-value NoSQL store, actually.
  
  2 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)