[umzxggtg] Haskell as if it were Lisp

> {-# LANGUAGE ScopedTypeVariables #-}
> module Main where {


Haskell's Data.Dynamic is rather nifty, allowing postponing type-checking until runtime.

> import Data.Dynamic;
> import Control.Monad(foldM);
> import Data.Maybe(fromJust);


This function takes a list of functions of different types [ a->b, b->c, c->d ] and composes them returning a->d, essentialy "fold (.)", a task unthinkable before Data.Dynamic.

Each function needs to be converted into Dynamic, and the result of the composition is wrapped in a Maybe if there is a type error. foldM uses the fact that Maybe is a Monad.

Type errors return "Nothing". It would be nice if there were a way to get more specific error messages.

> compose_list :: [Dynamic] -> Dynamic -> Maybe Dynamic;
> compose_list fs start = foldM (flip dynApply) start (reverse fs);


This function allows creating a list of functions for input into compose_list.

> cons :: Typeable a => a -> [Dynamic] -> [Dynamic];
> cons f fs = (toDyn f):fs;


Let us test it.

> my_list_of_funcs :: [Dynamic];
> my_list_of_funcs = cons h $ cons g $ cons dbl [];


> dbl :: String -> [String];
> dbl x = [x,x];
> g :: [String] -> [String];
> g x = "hello":x;
> h :: [String] -> [String];
> h = map (take 3);


Data.Dynamic cannot handle polymorphic functions. If the type signature were

h :: (Typeable a) => [[a]] -> [[a]];

then we get a pretty confusing error message:

    Ambiguous type variable `a0' in the constraint:
      (Typeable a0) arising from a use of `h'
    Probable fix: add a type signature that fixes these type variable(s)
    In the first argument of `cons', namely `h'
    In the expression: cons h
    In the expression: cons h $ cons g $ cons dbl []

> main :: IO ();
> main = case compose_list my_list_of_funcs (toDyn "world") of {
> Nothing -> putStrLn "1 fail";
> Just (i1::Dynamic) -> case (fromDynamic i1) of {
> Nothing -> putStrLn "2 fail";
> Just (i2::[String]) -> print i2;
> };
> };


output:
["hel","wor","wor"]

> }
>