Написать распознаватели для лексем

data Token = End | Id String | Num float

f::Int -> Maybe Int
 f 0 = Nothing
 f x = Just x

epsilon :: Parser ()
epsilon xs = Just ((), xs)
type Parser a =
       String -> maybe (a, String)

module Main where
 
import Prelude hiding((<*>))
import Data.Char
 
type Parser a = String -> Maybe (a,String)
 
--epsilon:: Parser ()
--epsilon xs = Just ( (), xs)
 
symbol _ [] =  Nothing
symbol a (x:xs) 
    | a==x = Just (a,xs)
    | otherwise = Nothing
 
satisfy:: (Char -> Bool) -> Parser Char
satisfy _ [] = Nothing
satisfy p (x:xs)
    | p x = Just (x,xs)
    | otherwise = Nothing
    
infixr 6 <*>
 
(p1 <*> p2) xs = case p1 xs of
                    Nothing -> Nothing
                    Just (y,ys) -> case p2 ys of
                                    Nothing -> Nothing
                                    Just(z,zs) -> Just ((y,z),zs)
 
infixr 4 <|>
 
(p1 <|> p2) xs = case p1 xs of
                    r@(Just _) -> r
                    Nothing -> p2 xs
 
many p xs = case p xs of
                Nothing -> Just ([],xs)
                Just (y,zs) -> Just (y:ys,ws)
                    where Just (ys,ws) = many p zs
 
infixr 5 <@ 
(p <@ f) xs = case p xs of                  
                    Nothing -> Nothing
                    Just(y,ys) -> Just (f y,ys)
        
data Token = End | Id String | Num Int
        deriving Show
 
digit = satisfy isDigit
 
letter = satisfy isAlpha
 
cons (x,xs) = x:xs
 
num = digit <*> many digit  <@ (Num . read . cons)
 
ide = letter <*> many (letter <|> digit) <@ (Id . cons)
 
endWord = symbol 'e' <*> symbol 'n' <*> symbol 'd' <@ (const End)
 
spaces [] =[]
spaces buff@(x:xs)
    | ord x <= 32 = spaces xs
    | otherwise = buff
    
token = endWord <|> ide <|> num  
 
tokens:: String -> [Token]
tokens xs = case (token.spaces) xs of
                Nothing -> []
                Just (tok,ys) -> tok: tokens ys
 
main :: IO () 
main = print $ tokens "qwe45 678 end"

<*>, <@, infix
import Prelude hiding((<*>))

import Prelude hiding((<*>))

infixr 6 <*>

token.spaces

just(tok, ys)

(.)    :: (b -> c) -> (a -> b) -> a -> c
(.) f g = \x -> f (g x)

ord x <= 32

foo =  case Just (1,2) of
             Just (x,y) -> 10*x+y
             Nothing -> 0

token = endWord <|> ide <|> num

endWord = symbol 'e' <*> symbol 'n' <*> symbol 'd' <@ (const End)

symbol 'd' <@ (const End)

endWord xs = (symbol 'e' <*> symbol 'n' <*> symbol 'd' <@ (const End)) xs

symbol :: Eq a => a -> [a] -> Maybe (a, [a])

letter <*> many (letter <|> digit)

[Id "qwe45",Num 678,End]