Haskell是否支持typeclass的匿名实例？

Question

I have the following code in F# (it's from a book)

open System.Collections.Generic

type Table<'T, 'U> =
   abstract Item : 'T -> 'U with get
   abstract Discard : unit -> unit

let memoizeAndPermitDiscard f =
     let lookasideTable = new Dictionary<_, _>(HashIdentity.Structural)
     {new Table<'T, 'U> with
      member t.Item
         with get(n) =
             if lookasideTable.ContainsKey(n) then
                 lookasideTable.[n]
             else
                 let res = f n
                 lookasideTable.Add(n, res)
                 res
      member t.Discard() = 
           lookasideTable.Clear()}
let rec fibFast =
     memoizeAndPermitDiscard (fun n ->  
     printfn "computing fibFast %d" n
     if n <= 2 then 1 else fibFast.[n - 1] + fibFast.[n - 2])

As we can see the abstract type Table take it's implementation in the function memoizeAndPermitDiscard . Can Haskell do the same?

Answer 1

Apologies in advance: I'm not an F# expert, so I may be misreading the F# code. But if I'm reading it right it's fairly straightforward to translate to Haskell:

data Table t u = Table { get :: t -> IO u, discard :: IO () }

memoize :: Hashable t => (t -> u) -> IO (Table t u)
memoize f = do
    tbl <- newHashTable
    return Table
        { get = \t -> do
            result <- lookupHashTable t tbl
            case result of
                Nothing -> let u = f t in writeHashTable t u tbl >> return u
                Just u -> return u
        , discard = clearHashTable tbl
        }

I'm assuming some suitable hash table implementation here that offers newHashTable , lookupHashTable , writeHashTable , and clearHashTable . Implementing these (or suggesting a library that offers them) is sort of beside the point of the question, I think.

Answer 2

I'm not an F# expert either, but I believe what you're describing is where you create a anonymous single-use subclass, by declaring in at the point where you create an object how it implements the methods of a superclass or interface? So it's really an anonymous class , not an anonymous instance (or rather, it's no more anonymous than any other object-oriented instance, which typically don't have names inherently, only variable names storing references to them).

It doesn't really make sense to do that with Haskell type classes/instances. The reason is that a Haskell instance represents something very different from an OO instance.

The instances of OO classes are objects (even the instances of interfaces are objects). All of a class' methods will always be invoked on an instance of that class. So it makes sense to create an anonymous subclass of an existing class or interface at the time you create a new object. You basically say how that object implements the required methods, as an alternative to declaring a whole named class of objects that implement the methods the same way, which you could instantiate in multiple places.

The instances of Haskell classes are types (which is why the're called type classes). All of the methods of a class must involve the type somehow, but there is no guarantee that they take an input of the type. For example, consider the class ¹ :

class Monoid' a
  where mempty' :: a
        mappend' :: a -> a -> a

It doesn't really make sense to say an object is an instance of Monoid' ; if I were to create a new object and I wanted to anonymously instantiate Monoid' , how would I define mempty' ? mempty' isn't an operation I could invoke on my new object, it's an operation that receives no inputs at all (not even an implicit "this") and produces a value ² .

And then there's things like:

class Functor' f
  where fmap :: (a -> b) -> (f a -> f b)

Nothing ever takes an input of a type f that is an instance of Functor' ; it doesn't even make sense to talk about something that might, since the instances of the class Functor' are type constructors that need a type parameter to result in a type, not types that actually contain values. So again, it just makes no sense at the point that I'm creating a new object to say "and here's how this object implements Functor' ").

It could potentially make sense to declare a new anonymous type locally, and declare how it implements some type classes at the same time. But Haskell has no syntax for it, no.

Fortunately, you also don't need to create anonymous classes/instances in order to have a one-off collection of functions that conforms to a known interface. Functions are first-class values too, so you can just have type whose fields are functions. Then anywhere you like you can create a new value of that type by providing a definition for all of the function fields. For example:

data MyInterface = MyInterface
  { foo :: Int -> Bool
  , bar :: Int -> String
  }

example :: MyInterface -> Int -> (Bool, String)
example impl x
  = (foo impl x, bar impl x)

main = do
  let impl = MyInterface { foo = even, bar = show }
  print $ example impl 7

The above program prints (False,"7") .

---

¹ I'm using Monoid' rather than Monoid (and similarly Functor' ) because I'm using simplifications of the real classes. You can see the real definition with :info Monoid in ghci (or look up the documentation) if you're interested.

² Or alternatively, the class Monoid' mandates that there simply exists a value of each type that instantiates it, and mempty' just is a reference to it.