Proiecte

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 () 
          }

. 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.

. 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.

http://www.haskell.org/haskellwiki/Ro/Boosting_your_Math._Faculty_with_Haskell

. O implementare Scheme la dispozitia dumneavoastra

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

. 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.