First Class Statements

http://blog.jle.im/entry/first-class-statements

by tel • 11 years ago

48 12 11 years ago

blog.jle.im

amelius• 11 years ago

Somehow this doesn't seem correct. If statements were truly "first class", one should be able to programmatically put statements together and execute them (without using the loophole of simply calling the compiler).

tikhonj• 11 years ago

I don't see how that's a "loophole". Your code has to tie into main somehow, but that's true of other languages too. Or you can call it from the repl. But it certainly doesn't make sense to talk about executing statements without bringing in the compiler or interpreter, in any language.

You can take a list of IO actions ("statements") and use the sequence function to get a single statement out.

    sequence :: Monad m => [m a] -> m [a]

Then you can execute the result by having it in the flow of your program, or pass it around just like any other statement.

The list of statements can be put together however you like.

wyager• 11 years ago

one should be able to programmatically put statements together and execute them

I'm not sure I understand. In Haskell, you can programmatically put statements together. You can't execute them willy-nilly just like how you can't try to execute an integer in python. You just create make a statement called "main" and the program is compiled so as to execute that statement.

comex• 11 years ago

Apparently Haskell does have a plugin that lets you eval expressions at runtime... from a string, though; is there a way to build an AST? (And what's the performance like?) Lisp of course would let you do something like

    (do-something-with '(+ a b))

and do-something-with could do any arbitrary transformation on the AST, possibly ending up passing it to eval, possibly optimizing it and compiling it to some other language... while Haskell's a leap in this regard compared to imperative languages, I think only something like Lisp can call its code truly first-class.

clickok• 11 years ago

To nitpick (and maybe derail this subthread a bit), you can do some pretty weird stuff with Python's numeric types. Unfortunately, the fascists who designed the language refuse to allow me to modify certain builtins...

  AttributeError: 'int' object has no attribute '__call__'

I mean, of course it doesn't, that's what I'm trying to fix.

At one point, I was desirous of having floating point numbers whose value decayed toward zero each time the number was accessed; you can achieve this by defining a custom class and implementing all the methods needed to make it behave like a float, but it's not the same.

jle• 11 years ago

You can programmatically put statements together, and manipulate them like real values. But that doesn't mean that pure simulated execution has to be a part of the API :)

shasta• 11 years ago

This isn't exactly true. For example, the article names declaration and assignment as among "statements", but such statements are not first class in Haskell. Nor are type, data, type class statements, etc. It is true that Haskell manages to accomplish many things with expressions that you'd use statements for in other languages.

tel2• 11 years ago

Agreed, but there's a pretty straightforward distinction between statements amenable to becoming values and those that aren't. Essentially, those which control and define the type theory are out of scope as well as those which introduce bindings.

dllthomas2• 11 years ago

I hope that "not amenable to becoming values" is a transient state...

wz1000• 11 years ago

I wouldn't call them statements because they aren't executed. Instead, I would classify them as "declarations". You state what something is, instead of telling the computer what to do.

Traditional assignment is an expression in Haskell.

    count :: Int -> IO Int
    count n = do r <- newIORef 0
                 loop r 1
           where 
             loop :: IORef Int -> Int -> IO Int
             loop r i | i>n       = readIORef r
                      | otherwise = do v <- readIORef r
                                       writeIORef r (v+i) 
                                       loop r (i+1)

First Class Statements

Related Stories