Personal tools

Proiecte

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
 
(working for a while)
Line 1: Line 1:
  +
== Proiectul JP e-book ==
  +
Isi propune sa ofere ajutor, cod sursa Haskell,ca prim model, pentru realizarea de manuale electronice ale limbilor straine sau/si pentru implementarea celor existente.
  +
  +
Exemple:
  +
O lucrare:
  +
Dan Popa, ''Combinatorii de analizoare sintactice – instrumentele lingviştilor pentru învăţarea asistată de calculator a limbilor străine''
  +
se poate descarca de la: http://www.haskell.org/wikiupload/9/96/Combinators.ps
  +
  +
O sursa de program:
  +
  +
<haskell>
  +
module Main where
  +
import Prelude hiding (read)
  +
import Monad
  +
import Data.Char
  +
  +
---- // O mica biblioteca de combinatori de parsere inspirata de Parselib
  +
-- Parser combinators : Graham Hutton and Erik Meijer
  +
  +
newtype Parser a = Parser (String -> [(a,String)] )
  +
  +
parse:: Parser a -> String -> [(a,String)]
  +
parse (Parser p) = p
  +
  +
  +
instance Monad Parser where
  +
return a = Parser (\cs -> [(a,cs)])
  +
p >>= f = Parser (\cs -> concat [parse (f a) cs' | (a,cs') <- parse p cs] )
  +
  +
  +
instance MonadPlus Parser where
  +
mzero = Parser (\cs -> [])
  +
p `mplus` q = Parser (\cs -> parse p cs ++ parse q cs)
  +
  +
  +
(+++) :: Parser a -> Parser a -> Parser a
  +
p +++ q = Parser (\cs -> case parse (p `mplus` q) cs of
  +
[] -> []
  +
(x:xs) -> [x]
  +
)
  +
  +
item :: Parser Char
  +
item = Parser (\xs -> case xs of
  +
"" -> []
  +
(c:cs) -> [(c,cs)]
  +
)
  +
  +
sat :: (Char -> Bool) -> Parser Char
  +
sat p = do { c <- item; if p c then return c else mzero }
  +
  +
  +
char :: Char -> Parser Char
  +
char c = sat (c ==)
  +
  +
string :: String -> Parser String
  +
string "" = return ""
  +
string (c:cs) = do {char c; string cs; return (c:cs) }
  +
  +
  +
many :: Parser a -> Parser [a]
  +
many p = many1 p +++ return []
  +
  +
many1 :: Parser a -> Parser [a]
  +
many1 p = do { a<-p ; as <-many p; return (a:as)}
  +
  +
  +
space :: Parser String
  +
space = many (sat isSpace)
  +
  +
token :: Parser a -> Parser a
  +
token p = do { a <- p; space ; return a}
  +
  +
symbol :: String -> Parser String
  +
symbol cs = token (string cs)
  +
  +
---- Programul nostru incepe aici ----
  +
  +
data Arb = Propozitie Arb Arb
  +
| Adjdem String
  +
| Subst String
  +
| Adj String
  +
| Subiect Arb Arb
  +
| PredicatN Arb Arb
  +
| VerbCopulativ String
  +
deriving Show
  +
  +
  +
subst = do { symbol "ie" ;
  +
return (Subst "ie") ;
  +
}
  +
+++
  +
do { symbol "kiku" ;
  +
return (Subst "kiku") ;
  +
}
  +
+++
  +
do { symbol "hon" ;
  +
return (Subst "hon") ;
  +
}
  +
+++
  +
do { symbol "koe" ;
  +
return (Subst "koe") ;
  +
}
  +
  +
-- <adj> -> "ookii" | "chiisai" | "omoshiroi" | "tsumaranai"
  +
adj = do { symbol "ookii" ;
  +
return (Adj "ookii") ;
  +
}
  +
+++
  +
do { symbol "chiisai" ;
  +
return (Adj "chiisai") ;
  +
}
  +
+++
  +
do { symbol "omoshiroi" ;
  +
return (Adj "omoshiroi") ;
  +
}
  +
+++
  +
do { symbol "tsumaranai" ;
  +
return (Adj "tsumaranai") ;
  +
}
  +
  +
-- <adjdem> -> "kono" | "sono" | "ano"
  +
adjdem = do { symbol "kono" ;
  +
return (Adjdem "kono") ;
  +
}
  +
+++
  +
do { symbol "sono" ;
  +
return (Adjdem "sono") ;
  +
}
  +
+++
  +
do { symbol "ano" ;
  +
return (Adjdem "ano") ;
  +
}
  +
  +
-- <subiect> -> <adjdem> <subst> "wa"
  +
subiect = do { a <- adjdem ;
  +
s <- subst ;
  +
symbol "wa" ;
  +
return (Subiect a s) }
  +
  +
-- <predicat> -> <adj> <vbcopulativ>
  +
predicat = do { a <- adj;
  +
vbc <- vbcopulativ;
  +
return (PredicatN a vbc); }
  +
  +
-- <vbcopulativ> -> "desu" | "dewa arimasen"
  +
vbcopulativ = do { symbol "desu" ;
  +
return (VerbCopulativ "desu"); }
  +
+++
  +
do { symbol "dewa" ;
  +
symbol "arimasen";
  +
return (VerbCopulativ "desu"); }
  +
  +
-- <propozitie> -> <subiect> <predicat>
  +
propozitie =
  +
do { x <- subiect ;
  +
y <- predicat ;
  +
return (Propozitie x y ) }
  +
  +
  +
-- Portions from "Practica interpretarii monadice"
  +
-- Dan Popa, MatrixRom Publishing House, Buc, 2009
  +
-- Parser combinators : Graham Hutton and Erik Meijer
  +
  +
-------------
  +
main ::IO()
  +
main =
  +
do { print "Simple Parser in Haskell.Grupul LOGOS, Bacau" ;
  +
print "4-5/mar/2010 -- Codename: 6A2" ;
  +
print "Exercitiu din Curs de Limba Japoneza";
  +
print "Angela Hondru, Ed Sirius Bucuresti, 1991" ;
  +
print "Lectia 2 pg 8 - IV Exercitii B (a)" ;
  +
print " ";
  +
print "Exercitiu:" ;
  +
print "Formulati propozitii dupa model folosind termenii indicati." ;
  +
print "Analizati sintactic propozitia formata.";
  +
print " ";
  +
print "kono ie wa ookii desu " ;
  +
print "sono kiku chiisai " ;
  +
print "ano hon tsumaranai " ;
  +
print " koe omoshiroi " ;
  +
raspuns <- getLine ;
  +
let rezultat = parse propozitie raspuns in
  +
if (null rezultat)
  +
then do { print "Raspuns incorect in raport cu cerintele." ; return (); }
  +
else do { print "Raspuns corect. Analiza sintactica terminata cu succes. " ;
  +
print rezultat ;
  +
putStrLn "----";
  +
return ()
  +
} ;
  +
return ()
  +
}
  +
</haskell>
  +
 
==. Proiectul Rodin ==
 
==. Proiectul Rodin ==
 
Realizarea unui limbaj imperativ care foloseste cuvinte cheie in limba romana. Recomandat pentru a fi utilizat de cadre didactice de la scolile din Romania, atunci cand elevii nu cunosc limba engleza si la orele de algoritmistica. Rezultatele, limbajul, exemplele de programe vor fi prezentate pe pagina [[Rodin]].
 
Realizarea unui limbaj imperativ care foloseste cuvinte cheie in limba romana. Recomandat pentru a fi utilizat de cadre didactice de la scolile din Romania, atunci cand elevii nu cunosc limba engleza si la orele de algoritmistica. Rezultatele, limbajul, exemplele de programe vor fi prezentate pe pagina [[Rodin]].
  +
  +
==. Proiectul RoBoosting ==
  +
  +
[[RoBoosting]] isi propune sa introduca limbajul Haskell ca limbaj de laborator de matematica. Este (o parte din) ceea ce le lipseste matematicienilor pentru a deveni competitivi: un mod de a transforma teoria intr-un produs vandabil. Haskell ca limbaj functional ofera un astfel de mod.
   
 
==. O implementare Scheme la dispozitia dumneavoastra ==
 
==. O implementare Scheme la dispozitia dumneavoastra ==
 
Proiect realizat cu sprijinul (si codul) oferit de echipa wikibooks ...
 
Proiect realizat cu sprijinul (si codul) oferit de echipa wikibooks ...
  +
   
 
==. Instrumente vizuale pentru Haskell ...==
 
==. Instrumente vizuale pentru Haskell ...==
Line 9: Line 207:
   
   
Pagina in curs de dezvoltare...
+
Pagina in curs de dezvoltare... nu am urmarit la zi stadiul evolutiei proiectelor, informati-vca de la paginile web ale acelor proiecte.
   
 
----
 
----

Revision as of 10:32, 24 March 2011

Contents

1 Proiectul JP e-book

Isi propune sa ofere ajutor, cod sursa Haskell,ca prim model, pentru realizarea de manuale electronice ale limbilor straine sau/si pentru implementarea celor existente.

Exemple: O lucrare: Dan Popa, Combinatorii de analizoare sintactice – instrumentele lingviştilor pentru învăţarea asistată de calculator a limbilor străine se poate descarca de la: http://www.haskell.org/wikiupload/9/96/Combinators.ps

O sursa de program:

module Main where
import Prelude hiding (read)
import Monad
import Data.Char
 
---- // O mica biblioteca de combinatori de parsere inspirata de Parselib
-- Parser combinators :  Graham Hutton and Erik Meijer
 
newtype Parser a = Parser (String -> [(a,String)] )
 
parse:: Parser a -> String -> [(a,String)]
parse (Parser p) = p
 
 
instance Monad Parser where
 return a = Parser (\cs -> [(a,cs)])
 p >>= f = Parser (\cs -> concat [parse (f a) cs' | (a,cs') <- parse p cs] )
 
 
instance MonadPlus Parser where
  mzero = Parser (\cs -> [])
  p `mplus` q = Parser (\cs -> parse p cs ++ parse q cs)
 
 
(+++) :: Parser a -> Parser a -> Parser a
p +++ q = Parser (\cs -> case parse (p `mplus` q) cs of
                          [] -> []
                          (x:xs) -> [x]
                  )
 
item :: Parser Char
item = Parser (\xs -> case  xs of 
                "" -> []
                (c:cs) -> [(c,cs)]
               )
 
sat :: (Char -> Bool) -> Parser Char
sat p = do { c <- item; if p c then return c else mzero }
 
 
char :: Char -> Parser Char
char c = sat (c ==)
 
string :: String -> Parser String
string "" = return ""
string (c:cs) = do {char c; string cs; return (c:cs) }
 
 
many :: Parser a -> Parser [a]
many p = many1 p +++ return []
 
many1 :: Parser a -> Parser [a]
many1 p = do { a<-p ; as <-many p; return (a:as)}
 
 
space :: Parser String
space = many (sat isSpace)
 
token :: Parser a -> Parser a
token p = do { a <- p; space ; return a}
 
symbol :: String -> Parser String
symbol cs = token (string cs)
 
---- Programul nostru incepe aici ----
 
data Arb = Propozitie Arb Arb 
         | Adjdem String
         | Subst String
         | Adj String
         | Subiect Arb Arb 
         | PredicatN Arb Arb
         | VerbCopulativ String 
         deriving Show
 
 
subst    = do { symbol "ie" ;
                        return (Subst "ie") ; 
                     }
                 +++ 
	  do { symbol "kiku" ;
                         return (Subst "kiku") ; 
                       }
                 +++
	  do { symbol "hon" ;
                        return (Subst "hon") ; 
                      }
                 +++
	   do { symbol "koe" ;
                         return (Subst "koe") ; 
                       }
 
--  <adj>    -> "ookii" | "chiisai" | "omoshiroi" | "tsumaranai" 
adj    = do { symbol "ookii" ;
                    return (Adj "ookii") ; 
                   }
               +++ 
	 do { symbol "chiisai" ;
                       return (Adj "chiisai") ; 
                    }
               +++
	 do { symbol "omoshiroi" ;
                       return (Adj "omoshiroi") ; 
                    }
               +++
	 do { symbol "tsumaranai" ;
                       return (Adj "tsumaranai") ; 
                    }
 
--  <adjdem> -> "kono" | "sono" | "ano" 
adjdem = do { symbol "kono" ;
                        return (Adjdem "kono") ; 
                     }
               +++ 
	 do { symbol "sono" ;
                       return (Adjdem "sono") ; 
                     }
               +++
	 do { symbol "ano" ;
                       return (Adjdem "ano") ; 
                     }
 
-- <subiect> -> <adjdem> <subst> "wa"
subiect = do { a <- adjdem ;
                        s <- subst ;
                        symbol "wa" ;
                        return (Subiect a s) }
 
-- <predicat> -> <adj> <vbcopulativ>
predicat = do { a <- adj;
                         vbc <- vbcopulativ;
                         return (PredicatN  a vbc); }
 
-- <vbcopulativ> -> "desu" | "dewa arimasen"
vbcopulativ = do { symbol "desu" ;
                               return (VerbCopulativ "desu"); }
                       +++
                       do { symbol "dewa" ;
                               symbol "arimasen";
                               return (VerbCopulativ "desu"); }
 
-- <propozitie>  -> <subiect> <predicat>
propozitie = 
  do { x <- subiect ;
          y <- predicat ;
          return (Propozitie x y )    }
 
 
-- Portions  from "Practica interpretarii monadice"
-- Dan Popa, MatrixRom Publishing House, Buc, 2009
-- Parser combinators :  Graham Hutton and Erik Meijer
 
-------------
main ::IO()
main = 
   do { print "Simple Parser in Haskell.Grupul LOGOS,  Bacau"   ;
            print "4-5/mar/2010           -- Codename: 6A2" ;
            print "Exercitiu din Curs de Limba Japoneza";
            print "Angela Hondru, Ed Sirius Bucuresti, 1991" ;
            print "Lectia 2 pg 8 - IV Exercitii B (a)" ;
            print " ";
            print "Exercitiu:" ;
            print "Formulati propozitii dupa model folosind termenii indicati." ;
            print "Analizati sintactic propozitia formata.";
            print " ";
            print "kono ie   wa ookii    desu " ;  
            print "sono kiku    chiisai       " ;
            print "ano  hon     tsumaranai    " ;
            print "        koe     omoshiroi     "  ;
            raspuns <- getLine ;
            let rezultat =  parse propozitie raspuns  in
            if (null rezultat)  
             then do { print "Raspuns incorect in raport cu cerintele." ;   return ();    }
            else do { print "Raspuns corect. Analiza sintactica terminata cu succes. "  ;
                        print rezultat ;                     
                        putStrLn "----";
                        return ()
                      } ;
          return () 
          }

2 . Proiectul Rodin

Realizarea unui limbaj imperativ care foloseste cuvinte cheie in limba romana. Recomandat pentru a fi utilizat de cadre didactice de la scolile din Romania, atunci cand elevii nu cunosc limba engleza si la orele de algoritmistica. Rezultatele, limbajul, exemplele de programe vor fi prezentate pe pagina Rodin.

3 . Proiectul RoBoosting

RoBoosting isi propune sa introduca limbajul Haskell ca limbaj de laborator de matematica. Este (o parte din) ceea ce le lipseste matematicienilor pentru a deveni competitivi: un mod de a transforma teoria intr-un produs vandabil. Haskell ca limbaj functional ofera un astfel de mod.

4 . O implementare Scheme la dispozitia dumneavoastra

Proiect realizat cu sprijinul (si codul) oferit de echipa wikibooks ...


5 . Instrumente vizuale pentru Haskell ...

La Bucuresti. (Prof C.G. si studenti.)


Pagina in curs de dezvoltare... nu am urmarit la zi stadiul evolutiei proiectelor, informati-vca de la paginile web ale acelor proiecte.


Pagina indexata la indexul Categories:Ro


<= Inapoi la inceputul paginii principale Ro/Haskell.

<- Inapoi la Intrebarile incepatorului Ro/Haskell.