Lambda the Ultimate

I found a reference to MrFlow (not Mr. Flow or Mr. Spidey, it looks like) which is unfortunately apparently perpetually "coming soon." I guess I'd also like a compiler-style interaction where I could get a report; it looks like MrSpidey and MrFlow require you to look at things via the GUI to notice what it figured out?

Alice ML definitely qualifies as a static type inference language. On the other side, Alice ML supports what it calls "Open Programming" with packages. Package types are inferred at run time when they are unpacked or unpickled.

Sorry Daniel. My type project is not related with MrFlow in any way. I'm sorry if I gave you that impression. Philippe Meunier built MrFlow. You should contact him if you want more information on his release plans.

Or, why doesn't Haskell count? As far as I know, if function is used polymorphically the compiler has to pass along a type indexed dictionary of functions which get dispatched at runtime. (Someone in the know might want to provide a more precise explanation). In other words, the following program...

data Foo = F Double Double deriving (Show, Eq)

instance Num Foo where
    (F a b) + (F c d) = F (a+b) (c+d)

main = do let x = F 1.0 1.0
          let y = F 2.0 3.0
          putStrLn $ "x + y = " ++ (show $ x + y)
          putStrLn $ "x * y = " ++ (show $ x * y)

...dies with a runtime error...

x + y = F 2.0 5.0
late_binding: late_binding.hs:3:0: No instance nor default method for class operation GHC.Num.*

...because there's no instance for '*' defined. I suppose you want to be able to extend the dictionaries at runtime. Maybe hs-plugins is what you're looking for? At least you get runtime eval...

import System.Eval.Haskell

main = do i <- eval "1 + 6 :: Int" [] :: IO (Maybe Int)
          if isJust i then putStrLn (show (fromJust i)) else return ()

Or you can always use dynamic types provided by Data.Dynamic ...

import Data.Dynamic

main = do
    let n = map (dynApply factorial)
                [toDyn (4::Int),toDyn (5::Int),toDyn ("six"::String)]
    print $ map (fmap (\x -> fromDyn x (0::Int))) n

factorial = toDyn (fac::Int->Int)

fac 0 = 1
fac n = n*(fac (n - 1))

infers static types... allows for late binding... but none are particularly 'main stream'

Seems like you have an additional requirement that the language be 'main stream' - so let me suggest that you list the languages you consider to be 'main stream' and then eliminate all those that don't provide type inference or allow late binding.

As an aside: The problem with checking dynamic behaviour is, at least, that there is so much to possibly check. A possible solution, some day, would be the application of quantum computers to search the entire (or some large amount of the) dynamic state space for violations of defined rules. Come on, science!

• Functional Programming with Dynamic Binding

  Dynamic binding is a runtime operation which looks up some names in some environments: examples are quote and eval in LISP or object-oriented message passing. We present a functional language, in the spirit of ML or Haskell, which supports dynamic binding. At the surface level, the language supports constructs such as extensible records, variants, extensible case selection, quoted terms, and can encode various forms of objects. The underlying execution model is a lambda-calculus with name-based (labels, keywords) parameter passing. The type system supports subtyping, through an extension of Hindley-Milner type inference with recursively constrained types.