merge conf

README

@@ -0,0 +1 @@
+Yeeeah, you read me!

haskell.hiji.js

@@ -97,7 +97,56 @@ commands[":help"] = "HELP";
                 {
                     try {
                         var newLine = makeEntered(modules, line);
-                        var output = makeOutput(evaluateHaskell(line, env));
+
+                        var showResult = function(result) {
+                            if (result.type == "Data") {
+                                var str = result.identifier;
+                                var op = " ";
+
+                                if (str == "I#") {
+                                    str = "";
+                                } else if (str == ":") {
+                                    str = "";
+                                    op = ",";
+                                }
+
+                                if (result.ptrs) {
+                                    var first = true;
+                                    for (var i = 0; i < result.ptrs.length; i++) {
+                                        if (str.length == 0 && first) {
+                                            str = showResult(result.ptrs[i].dereference());
+                                            if (str.str) 
+                                                str = str.str;
+                                            first = false;
+                                        } else {
+                                            var res = showResult(result.ptrs[i].dereference());
+                                            if (res.str)
+                                                res = res.str;
+                                            str = str + op + res;
+                                        }
+                                    }
+                                }
+
+                                return { str: str, isList: op == "," };
+                            } if (result.force) {
+                                return result.force();
+                            } else if (result.ptrs) {
+                                return result.ptrs[0].dereference();
+                            } else {
+                                return result; 
+                            }
+                        }
+
+                        var result = showResult(evaluateHaskell(line, env));
+                        if (result.isList) {
+                            result = result.str;
+                            result = result.substring(0, result.length - 3);
+                            result = "[" + result + "]";
+                        } else if (result.str) {
+                            result = result.str;
+                        }
+
+                        var output = makeOutput(result);
                         $('.input', this).after(output).replaceWith(newLine);
                         $("ol",this).append(makeInput(modules));
                     }

haskell.parser.js

@@ -671,7 +671,7 @@
 
         var gdrhs_fix_list_action = function(p) {
             return action(p, function(ast) {
-                return ast[0];
+                return ast;
             });  
         };
 
@@ -691,7 +691,7 @@
         };
 
         var rhs = choice(   decl_rhs_action(sequence(expect(ws('=')), ws(exp), optional(sequence(expect(ws("where")), ws(decls))))),
-                            sequence(ws(gdrhs), optional(sequence(expect(ws("where")), ws(decls))))
+                            rhs_gurad_action(sequence(ws(gdrhs), optional(sequence(expect(ws("where")), ws(decls)))))
                         );
 
         // todo: Should be quite a lot of choices here, but those are for 

hiji.css

@@ -1,3 +1,7 @@
+body {
+    background-color: #000000;
+}
+
 .ghci-look * {
     margin:0;
     padding:0;
@@ -21,13 +25,14 @@
 }
 
 .ghci-look .input input {
-    border:none;
+    border:0;
     display:inline-block;
     margin-left:-1px;
     background-color: #000;
-    width : 50%;
+    width : 90%;
     color: #fff;
     font-size: 12px;
+    outline: none;
 }
 
 .ghci-look .modules {

hs/Prelude.hs

@@ -29,6 +29,7 @@ otherwise = True
 
 id x = x
 
+
 map f xs = case xs of
     [] -> []
     (x:xs) -> f x : map f xs
@@ -43,11 +44,9 @@ foldr1 f xs = case xs of
     [x] -> x
     (x:xs) -> f x $ foldr1 f xs
 
-filter f xs = case xs of
-    [] -> []
-    (x:xs) -> case f x of
-        True -> x : filter f xs
-        False -> filter f xs
+filter _ [] = []
+filter f (x:xs ) | f x = x : filter f xs
+                 | otherwise = filter f xs
 
 iterate f x = f x : iterate f x
 

rapport/kallor.bib

@@ -11,6 +11,14 @@ @misc{ghc
     year  = 2010
 }
 
+@misc{json,
+    title = "The application/json Media Type for JavaScript Object Notation (JSON)",
+    author = "D. Crockford",
+    url    = "http://www.ietf.org/rfc/rfc4627.txt?number=4627",
+    year   = 2006,
+    note   = "Hämtad 2010-05-15"
+}
+
 @misc{jsparse,
     title = "JSParse - Javascript Parser Combinators",
     url   = "http://www.bluishcoder.co.nz/2007/10/javascript-parser-combinators.html",
@@ -19,6 +27,7 @@ @misc{jsparse
 }
 
 @misc{jquery,
+    author = "The jQuery Project",
     title = "jQuery",
     url   = "http://jquery.com/",
     year  = 2010
@@ -49,7 +58,7 @@ @inbook{haskell98chap3
 
 @unpublished{haskell2010,
     title = "Haskell 2010 Language Report",
-    editor = "S. Marlow",
+    author = "S. Marlow",
     year = 2010,
     month = "April",
     note = "The draft of the report" 
@@ -89,17 +98,24 @@ @conference{fang01
 }
 
 @INPROCEEDINGS{jones99,
-    author = {Mark P. Jones},
+    author = {Jones, M. P.},
     title = {Typing Haskell in Haskell},
     booktitle = {Haskell Workshop},
     year = {1999},
     publisher = {}
 }
 
-@inbook{haskell98chap3,
-    title = "",
-    editor = "S. P. Jones",
-    year   = 2003,
-    publisher = "Cambridge Univeristy Press",
-    chapter = 3
-}
+@inbook{dragonbookchap6,
+    title = "Compilers: Principles, Techniques, and Tools (2nd Edition)",
+    author = {Aho, A. V. and Lam, M. S. and Sethi, R and Ullman, J. D.},
+    year   = 2006,
+    publisher = "Addison Wesley",
+    chapter = 6
+}
+
+@book{pierce02,
+    author       = "Pierce, B. C.",
+    year         = 2002,
+    title        = "Types and Programming Languages",
+    publisher    = "MIT Press",
+}

rapport/kapitel/abstract.tex

@@ -1,16 +1,13 @@
 \renewcommand{\abstractname}{Abstract}
     \begin{abstract}
 Haskell is not a widely used programming language, nor very known to the average programmer. By implementing a subset of the Haskell 98 specification in Javascript our intention is to make it  possible to run Haskell in a web browser, thus making it easier for beginners to try Haskell by eliminating the need of downloading Haskell compilers such as GHC. 
+In this paper we describe the process and result from the project of implementing Haskell in Javascript. 
 \\
 \\
-In this paper we describe the process and result from the project of implementing Haskell in Javascript. 
 Our result consists of a parser, type checker, interpreter and a front end similar to GHCi.
-The parser process the text input, creating an internal structure called abstract syntax tree (AST). The type checker then analyse the AST to confirm that there are no type errors. If no errors have been detected, the AST is sent to the interpreter. The interpreter then interpret the AST in an well defined way.
+The parser process the text input, creating an internal structure called abstract syntax tree (AST). The type checker then analysis the AST to confirm that there are no type errors. If no errors have been detected, the AST is sent to the interpreter. The interpreter then interprets the AST in an well defined way.
 \\
 \\
-The results shows that it's possible to successfully implement Haskell in Javascript,  but a lot of more work need to be done for making a newbie-friendly environment for learning Haskell. 
-
-
-'
+The results show that it is possible to successfully implement Haskell in Javascript,  but a lot of more work need to be done for making a newbie-friendly environment for learning Haskell. 
 
     \end{abstract}

rapport/kapitel/diskussion.tex

@@ -1 +1,34 @@
 \section{Diskussion}
+Vi har skapat en javascriptapplikation som kan parsa, typchecka och interpretera stora delar av Haskell 98. Det som saknas är fullständigt stöd för typklasser där stödet endast finns i typcheckaren men fortfarande behöver implementeras i interpretatorn. Detta handlar främst om förmågan att välja rätt instanser av typklasser vid applicering av överlagrade funktioner.
+
+Sett till planeringen har vi lyckats uppfylla alla milstolpar utom typklasser, dock inte enligt den ordning och tidsplan som ursprungligen planerades. 
+Vi insåg att det var enklast att utveckla parsern, typcheckaren och interpertatorn parallelt och bestämma individuellt vad som skulle implementeras och i 
+vilken ordning för att senare, oftast en gång i veckan, samordna och implementera det som behövdes i flera delar.
+
+Vi har inte implementerat NPlusK-pattern i parsern och då de är borttagna i Haskell 2010 \citep{haskell2010} känner vi att det inte behövs.
+
+
+% TODO typcheckaren kom aldrig in i den slutgiltliga versionen. Ö:
+
+
+
+\subsection{Framtida förbättringar}
+
+Syftet med projektet, att skapa en fungerande Haskelltolk i javascript, har vi lyckats implementera om man tar hänsyn till de avgränsningar som är uppsatta. Dock om man ser till motivationen bakom projektet, att vår Haskelltolk ska kunna användas som grund för att skapa en webbaserad interaktiv läroplattform, så finns det fortfarande mycket kvar att utveckla. Framförallt handlar det om att göra Haskelltolken och HIJi mer lättanvänd för nybörjare inom funktionell programmering.
+
+I parsern har vi identifierat två förbättringsmöjligheter. För det första, bättre felmeddelanden
+Hjälpsamma och förklarande felmeddelanden är en viktigt del av ett utvecklingsverktyg och det generars för tillfället inte av parsern. 
+Om parsern stöter på ett fel rapporterar den endast att ett fel har inträffat och avslutar parsningsprocessen. 
+Att förbättra dessa felmeddelanden med exempelivs rad- och kolumnnummer och specifik information om vad för fel som har inträffat skulle göra parsern mer användbar.
+För att implentera detta behöver man kombinera steg 1 och 2 i parsningen för att rad- och kolumn-nummer ska bevaras korrekt då borttagning av nästlade kommentarer kan påverka dessa.
+JSParse behöver modifieras så att det rapporterar var ett fel uppstod och i vilken parser.
+
+För det andra, konverteringen av icke kontextfri Haskellkod till kontextfri kan förbättras 
+för att klara av att expandera måsvingar i \emph{[x | let x = 5]}. 
+För att klara av detta behövs en parser som räknar antal måsvingar, paranteser, 
+komman och hakparanteser efter \emph{let} och avgöra när det är korrekt att sätta in avslutande måsvingar.
+
+Även i HIJi finns det förbättringar att göra.
+Det som framförallt behöver utvecklas är, för det första, erbjuda en interaktiv tutorial där användaren får instruktioner vad som ska skrivas in i HIJi. Om användaren skriver in rätt uttryck fortsätter tutorialen till nästa nivå.
+För det andra, visa typinformation från funktioner genom att hålla musen över funktionsnamnet.
+Och tillsist, kunna stega igenom ett program eller funktion för att kunna se vad som händer i varje evalutionssteg. 

rapport/kapitel/inledning.tex

@@ -5,6 +5,8 @@ \subsection{Bakgrund och motivation}
 Många programmerare kommer inte i kontakt med funktionell programmering  och med hjälp av ett interaktivt webbbverktyg som är enkelt för användaren att använda är vår förhoppning att fler programmerare och studenter ska komma i kontakt med funktionell programmering, och i synnerhet Haskell. Då flera moderna objektorienterade programmeringsspråk börjar ta funktionalitet och begrepp från funktionella programmeringsspråk så är det extra viktigt att programmerare kommer i kontakt med funktionell programmering. Ett exempel på detta är C\# som i senare versioner har fått stöd för bland annat lambdafunktioner \citep{csharp}. 
 
 En fördel med att ha tolken på webben är att det enda som behövs för att använda den är en javascriptkompatibel webbläsare, något som följer med i princip i alla moderna operativsystem. Detta betyder att de användare som befinner sig inom vår målgrupp redan har den programvaran som behövs på sina hemdatorer för att använda sig av vårt program.  
+
+% TODO  detta e out of context`
 Haskell är ett starkt statiskt typcheckat och funktionellt programmeringsspråk med lat evaluering. % TODO: Citera, skriv om ifall det är direktöversatt
 % jag bytte från strikt semantik till lat evaluering:p
 Att språket är funktionellt innebär bland annat att funktioner är \emph{first-class citizens} och kan därmed användas som parametrar och returneras från andra funktioner precis som vilken annan typ som helst.
@@ -18,12 +20,12 @@ \subsection{Bakgrund och motivation}
 Dessa två programspråksegenskaper bidrar till att program skrivna i Haskell är generellt sätt kortare och går fortare att skriva än motsvarande program skrivet i ett imperativt programmeringsspråk  \citep{why}.
 
 Med ovan nämnda resonemang ser vi det som ovärderligt för programmerare att komma i kontakt och lära sig funktionell programmering. 
-Förhoppningen är att vår Haskelltolk i Javascript ska kunna användas som grund för att i framtiden göra en interaktiv läroplattform för nybörjare i funktionell programmering. 
+Förhoppningen är att vår haskelltolk i Javascript ska kunna användas som grund för att i framtiden göra en interaktiv läroplattform för nybörjare i funktionell programmering. 
 
 
 \subsection{Syfte}
-Syftet är en implementera en fungerande Haskelltolk i Javascript. Den ska kunna tolka en delmängd av Haskell-specifikationen så den kan användas för att göra exempelvis interaktiva tutorials för nybörjare.
-Meningen är att dessa ska kunna köras i en vanlig webbläsare utan att ladda ner en Haskellkompilator, till exempel GHC, eller behöva lära sig svårbegripliga kommandon.
+Syftet är en implementera en fungerande haskelltolk i Javascript. Den ska kunna tolka en delmängd av haskell-specifikationen så den kan användas för att göra exempelvis interaktiva tutorials för nybörjare.
+Meningen är att dessa ska kunna köras i en vanlig webbläsare utan att ladda ner en haskellkompilator, till exempel GHC, eller behöva lära sig svårbegripliga kommandon.
 
 \subsection{Problembeskrivning} 
 %% WHAT THE FACK SKA VI SKRIVE HEAR?!!Ö!
@@ -43,15 +45,14 @@ \subsection{Metod}
 %Vi kommer att integrera jQuery \citep{jquery} för att få ett unisont stöd för samtliga webbläsare. jQuery kommer även underlätta arbetet med att skapa ett enkelt och stilrent interaktivt gränssnitt.
 
 \subsubsection{Avgränsningar} 
-Att tolka Haskell i Javascript är inget trivialt projekt och därför kommer inte hela Haskell att implementeras. Vi kommer implementera en delmängd av den version av Haskell som kallas Haskell 98.
-De delar som prioriteras är
+Att tolka Haskell i Javascript är inget trivialt projekt och därför valde vi att avgränsa implementationen till de mest centrala och viktiga delarna i haskellspecifikationen. De delar vi valde att fokusera på är:
         \begin{enumerate}
             \item{Lambda-funktioner, namngivna funktioner}
             \item{Typer, generella typer, algebraiska datatyper}
             \item{Typklasser}
             \item{Pattern matching}
             \item{Guards}
         \end{enumerate}
-Med dessa delar implementerade kan de flesta enklare Haskellprogram köras och bör vara tillräckligt för det stora flertalet nybörjare. Vi kommer ej lägga någon tid på att skapa en användarvänlig webbsida utan fokus kommer ligga på att skapa Haskelltolken. Dock kommer en kommandotolk som körs på en webbsida utvecklas för att kunna kommunicera med Haskelltolken. 
-Vi kommer inte lägga någon nämnvärd tid på att optimera Haskelltolken utan målet är att göra en fungerande implementation. 
+Med dessa delar implementerade kan de flesta enklare haskellprogram köras och bör vara tillräckligt för det stora flertalet nybörjare. Vi beslutade att ej lägga någon större tid på att skapa en användarvänlig webbsida, utan fokus låg på att skapa haskelltolken. Dock valde vi att utveckla en kommandotolk som skulle köras på en webbsida för att kunna kommunicera med haskelltolken. 
+SLutligen beslutades det att inte optimera haskelltolken utan målet är att göra en fungerande implementation.