News for hackers. Stuff that matters.
Re:Thinking in Types by AnimalMuppet on Friday May 02, 2014 @02:37PM (#7687331)
I'm not sure that this works in more general cases, though.

If I have a more general game with more objects of more types in it, adding each type to the render function is going to get old. In object oriented programming, I'd just call render() on each entry in the list of game objects. But this approach is going to lead me to:

- render each entry in the list of Foo objects

- render each entry in the list of Bar objects

- render each entry in the list of Baz objects

- ...

which doesn't seem to me to work out very well as the game grows more complicated.

(Sorry about all the line breaks - I can't seem to figure out how to get HN to display it right without them.)

Re:Thinking in Types by gizmo686 on Friday May 02, 2014 @08:04PM (#7688923)
This approach seems to be what people new to Haskell gennerally go to first (probably because it is the natural solution given the type system). However, as much as we Haskellers hate to admit it, there are design patterns in Haskell that can offer more maintainable solutions that what the language naively presents.

In this case, a common pattern is to copy the OO concept of casting. For example, instead of having:

    class Render a where 
    render :: a -> IO()
we could have:

    class Renderable a where
    toRender a -> Render
along with:

    data Render = ...
    render :: Render -> IO()
    render r = ...
This leads to some noise with needing to put a bunch of toRender functions in a short amount of code, but this problem does not get worse as complexity increases.
Re:Thinking in Types by andolanra on Friday May 02, 2014 @11:20PM (#7689422)
My preferred way to approach this, in Haskell specifically, is to use records as a naïve encoding of objects or interfaces. For example, expanding on the functionality a little bit:

    data GameEntity = GameEntity
        { render      :: IO ()
        , getPosition :: Point
        , setPosition :: Point -> GameEntity
        }

    makeBall :: Point -> GameEntity
    makeBall pos = GameEntity { render      = myRender
                              , getPosition = pos
                              , setPosition = mySetPos
                              }
        where myRender = {- draw the ball somehow -}
              mySetPos newPos = makeBall newPos
    
    {- and similar for makePlayer -}
That means that the rendering code will look like

    renderAll :: [GameEntity] -> IO ()
    renderAll allEntities = mapM_ render allEntities

    main = do
      pl = makePlayer 1 (0, 5.0)
      p2 = makePlayer 2 (10.0, 5.0)
      b  = makeBall (5.0, 5.0)
      {- ... -}
      renderAll [p1, p2, b] -- type-checks correctly now
What I've done is used a record type to encode the interface that it's supposed to expose, while hiding exactly what the particular implementations of the interface are. It's also nicely extensible; if I wanted to add in some other kind of entity—say, a turtle—all I'd need to do is add a function like

    makeTurtle :: Point -> ShellColor -> TurtleDisposition -> GameEntity
and nothing else need be changed.
Re:Thinking in Types by zvrba on Saturday May 03, 2014 @01:33AM (#7689750)
> What I've done is used a record type to encode the interface that it's supposed to expose,

I love how Haskellers (in general, not you in particular) bash OO and then come up with the exact same technique of simulating OO that is used in C (a struct of function pointers). Something which OO languages provide out of the box (interfaces, virtual methods, etc).

Now, let's take this a step further: how would you simulate double-dispatch, or multiple dispatch in Haskell? This is sorely missing from mainstream OO languages.

Re:Thinking in Types by tel on Saturday May 03, 2014 @08:48AM (#7690558)
I don't think Haskellers bash OO that much. They bash some of the trappings of it. GoF is usually a typesafe library in Haskell because it has better abstraction capabilities. Functions form better fundamental units than objects do (but are a form of "object" themselves). Composition is better than inheritance. Classes are not generally so useful.

Really, I think Haskell has a super great object system. It's just (a) not the central conceit and (b) so naturally embedded in the language that you can program for a long time without even noticing it's there.

Codata typically indicates you're looking at an object. In Haskell, due to it being non-terminating as a language, codata and data are unified so most "objects" look identical to their non-object form. You can also notice them by definitions based on eliminators. Automata are a good example

    newtype Auto f i o = Auto { run :: i -> f (Auto f i o, o) }
You can also look for objects as ADTs. When you do this you can get a natural embedding of a prototype-based language. (http://www.cs.ox.ac.uk/jeremy.gibbons/publications/adt.pdf)

    data ADT f = forall st 
               . ADT { unfold :: st -> f st
                     , state  :: st
                     }
Here, the internal state type `st` is closed over as an existential value—when you create a new ADT you can pick what st is but the type system then ensures that nobody ever can access that type again. Instead, you have to use the `unfold` elimination form which projects the state into a "class" `f` (represented as a Functor, but that's immaterial) which defines a signature of methods over the abstract state. Auto, from before, is definable this way.

    data AutoClass st o = 
      AutoClass { next :: st
                , out  :: o
                }

     type Auto = ADT AutoClass
Subtyping occurs naturally with quantified types like the existentially-typed `st` variable or the universally quantified types you see all the time in type signatures. It's a more natural form of subtyping since it's all defined by increasing typeclass bounds. Something like

        {C} : set of constraints    Ci : constraint
    ------------------------------------------------------
    forall a . {C} a => a :> forall a . ({C} a, Ci a) => a
This guarantees that these these two types are good "subtypes on eliminators" which satisfies the Liskov Substitution Principle if not some of the more strict definitions of subtype "niceness".

Double/Multiple dispatch is trivially handled in Haskell since polymorphism is solved by an entire Prolog embedded in the type system.

The thing is that Haskell also has initial data, things like finite lists are better thought of as a big tree of constructors

    1:(2:(3:(4:(5:[]))))
and then pattern matched upon (defining catamorphisms)

    sum :: [Int] -> Int
    sum (a:bs) = a + sum bs
    sum []     = 0
and this pattern is perhaps a little bit emphasized in mainstream Haskell because it sides on the "functional" side of the expression problem. It doesn't mean, though, that Haskell doesn't like the "object oriented" side, but instead that Haskell favors both.
Re:Thinking in Types by andolanra on Saturday May 03, 2014 @05:28AM (#7690145)
I can't speak for the community as a whole, but the Haskellers I know generally "bash" OO with respect to its use of pervasive mutable state and open recursion, and not because the notion of "object" is an inherently wrong one. Those features must be explicitly included in the above model of object (by manually including reference cells and manually invoking a "method" with its own "instance", respectively) whereas they are implicitly included in every object in most commonly-used OO languages.

As for multiple dispatch, you could always use multi-param type classes:

    {-# LANGUAGE MultiParamTypeClasses #-}

    class Say a b where say :: a -> b -> IO ()
    instance Say Int ()  where say = putStrLn "Case one"
    instance Say Int Int where say = putStrLn "Case two"
which corresponds roughly to the CLOS snippet

    (defgeneric say (a b))
    (defmethod say ((a integer) (b null)) (format t "Case one"))
    (defmethod say ((a integer) (b integer)) (format t "Case two"))
I do not believe that there is a way to use the record-based model of objects I showed earlier to do the same thing, but perhaps there is some way that is presently eluding me.
Re:Thinking in Types by dllthomas on Saturday May 03, 2014 @12:56PM (#7691421)
There is a slight technical difference that winds up being a more significant practical difference between the C solution (struct of function pointers) and the Haskell solution (record of Haskell functions): the Haskell functions can close over arbitrary data.
Re:Thinking in Types by stonemetal on Friday May 02, 2014 @04:51PM (#7688049)
That problem gets especially harry once you consider every subsystem in the game is going to behave similarly, AI, physics, Sound, etc.

It seems like the right answer is the same as it is in OO languages favor composition. Grab the Renderable out of the Foos, Bars, and Bazes then pass that list to the render function. It follows the articles suggestion about think about your types more. Why does anyone think the render function needs the entire player state instead of just the part it needs to render something on the screen?

Re:Thinking in Types by mkehrt on Friday May 02, 2014 @07:51PM (#7688862)
Sure it does. In object oriented languages, you still have to write all of the same code, you just group it by what data it affects. In (strongly typed) FP, you're writing the same code, but now it's grouped by functionality, rather than by data type.
Re:Thinking in Types by zmoazeni on Friday May 02, 2014 @02:55PM (#7687429)
The post links to this page http://www.haskell.org/haskellwiki/Heterogenous_collections and one of other solutions is to use existential types to do it. But the author even said:

However, I don’t think this is a good use case. We can get around this problem in a cleaner and safer way by using the type system rather than subverting it.

Re:Thinking in Types by AnimalMuppet on Friday May 02, 2014 @03:22PM (#7687599)
Right, I know he said that. But my point is, his solution doesn't scale well to a more complicated problem. (Unless I misunderstood either his solution or your point?)
Re:Thinking in Types by tel on Friday May 02, 2014 @04:19PM (#7687887)
There are more real solutions which scale better, but in these toy problems it's hard to get to the meat of the problem. Sometimes the "existential antipattern" is a good choice (see Oleg's finally tagless encoding of, say, the linear lambda calculus). Sometimes creative use of static structure can scale much more neatly than lists of concrete objects.