i’m learning haskell

Daniel Molina Wegener — Mon, 23 Nov 2009 00:55:09 +0000

My experience with Functional Programming Languages is small. I’ve been writing small hacks for emacs lisp, such as hooks for certain modes and actions for a while, and sometimes building small tools in SBCL. Someone on Internet has recommended me an interesting book about Haskell called "Real World Haskell", that may be read on-line. I’ve been reading the book in my free time, and playing with the Haskell syntax, building small functions and playing with data type. So the result of those games is a small program that I want to share with you.

First, I was playing with some business data types, and I’ve defined some data types for Haskell:

data Role = Undefined
          | Researcher
          | Engineer
          | Scientist
            deriving (Eq, Show)

data Person = Person {
      pid               :: Int
    , name              :: String
    , born              :: Int
    } deriving (Eq, Show)

data Employee = Employee {
      who               :: Person
    , role              :: [ Role ]
    } deriving (Eq, Show)

data Company = Company {
      cName             :: String
    , employee          :: [ Employee ]
    } deriving (Eq, Show)

For me, data type signatures matters. I prefer strongly typed languages, instead of the ambiguity of some others. Then I’ve defined some variable to string conversion functions, so I can display the structure of the Company data type.

asStringPerson :: (Person) -> String
asStringPerson (p) = ( name p )
                     ++ " [" ++ ( show ( born p ) ) ++ "]"

asStringEmployee :: (Employee) -> String
asStringEmployee (e) = "\n" ++ ( asStringPerson ( who e ) )
                       ++ " as " ++ ( show ( role e ) )

asStringEmployeeList :: ( [ Employee ] ) -> String
asStringEmployeeList (el) = do let s :: String
                                   s = ""
                               foldr (\i a -> ( a ++ ( asStringEmployee i ) ) ) s el

asStringCompany :: (Company) -> String
asStringCompany (c) = ( cName c ) ++ " has employeed "
                      ++ ( asStringEmployeeList ( employee c ) )

The magic of foldr that turns the el parameter of type [ Employee ] into a string is like the magic on the semantics of (map #’(lambda x) ()) in Lisp. But looking at the documentation of Hakell, it has support for a wide variety of map-work-alike functions

main :: IO ()
main = do let someone1P :: Person
              someone1P = Person {
                            pid = 1
                          , name = "Juan Perez"
                          , born = 1927
                          }
              someone1E :: Employee
              someone1E = Employee {
                            who = someone1P
                          , role = [ Researcher, Scientist ]
                          }
              someone2P :: Person
              someone2P = Person {
                            pid = 2
                          , name = "Perico Palotez"
                          , born = 1929
                          }
              someone2E :: Employee
              someone2E = Employee {
                            who = someone2P
                          , role = [ Engineer, Scientist ]
                          }
              aiCompany :: Company
              aiCompany = Company {
                            cName = "IA Company"
                          , employee = [ someone1E, someone2E ]
                          }
          putStrLn ( asStringCompany aiCompany )

The main program instantiates a group of Employee data types and puts them in the aiCompany as Company data type is. If you take a little bit of attention on the code, I’m worried of some significant details, such as naming and signing data types properly, since I prefer that nomenclature for readability.

I shall continue learning it. I think that the code is elegant, mainly since I can use monadic features, which reduces the lines of code and make the program more legible too. You can download the source code for this toy program here.

share this article at:

coder . cl » haskell

i’m learning haskell