March 2015 - Beginners

Re: [Haskell-beginners] Maybe and Just
by Corentin Dupont 27 Mar '15

27 Mar '15

Not really, when you define the type "Maybe a": data Maybe a = Just a | Nothing Haskell is creating automatically two functions for you: Just :: a -> Maybe a Nothing :: Maybe a In the first case, you can think of "Just" and "Nothing" as a sort of tag identifying which element of the sum you have. It the second case it's a function, with the same name. A more informed person than me could say if they are indeed separated of if they are the same thing in GHC... On Thu, Mar 26, 2015 at 5:34 PM, Shishir Srivastava < shishir.srivastava(a)gmail.com> wrote: > isn't that then cyclic dependency between 'Maybe' and 'Just' ...where the > first one is defined in terms of second and vice-versa...? > > Shishir > > > On Thu, Mar 26, 2015 at 3:48 PM, Corentin Dupont < > corentin.dupont(a)gmail.com> wrote: > >> Hi Shishir, >> I think that's a legitimate question. >> >> By writing >> >> data Maybe a = a | Nothing >> >> you are saying that the type of the left hand side of the = is the same >> that right hand side (you are defining a type basically). >> Also you can only sum things of the same type. >> So you are saying: >> type "Maybe a" = type "a" >> Which is wrong. >> That's why "a" should be wrapped into something: >> type of "Just a" is indeed "Maybe a". >> >> "Just" is a type constructor: >> Just :: a -> Maybe a >> It allows you to build the Maybe. >> >> Said that, "Just" is a vocabulary choice. >> Personally I prefer the name choices of OCaml, Rust, Scala etc.: Option >> a = None | Some a >> >> >> >> On Thu, Mar 26, 2015 at 4:26 PM, Shishir Srivastava < >> shishir.srivastava(a)gmail.com> wrote: >> >>> ok..but what's with using the keyword 'Just' ? why cannot 'Maybe' be >>> defined like this >>> >>> data Maybe a = a | Nothing >>> >>> what's the point in having 'Just' keyword ? >>> >>> Shishir >>> >>> >>> On Thu, Mar 26, 2015 at 10:26 AM, Michael Alan Dorman < >>> mdorman(a)ironicdesign.com> wrote: >>> >>>> Shishir Srivastava <shishir.srivastava(a)gmail.com> writes: >>>> > After reading and re-reading the haskell tutorials I don't happen to >>>> > see a very convincing or appealing reason for having these data >>>> > types. >>>> >>>> To be clear: Maybe is the data *type*. Just and Nothing are its data >>>> *constructors*. >>>> >>>> > Can anyone please explain where Maybe and Just provide the sort of >>>> > functionality that cannot be achieved in other languages which don't >>>> > have these kind. >>>> >>>> The functionality can be achieved in other languages, certainly. The >>>> question is whether the clarity and safety is also achieved. >>>> >>>> When I see (as a totally contrived example): >>>> >>>> fopen :: Maybe FileHandle >>>> >>>> I know that that function may not be able to return a FileHandle value >>>> all the time. The compiler will, in fact, nag me if I do not write the >>>> code that calls it in such a way that it acknowledges that possibility. >>>> >>>> When I see: >>>> >>>> FILE * fopen ( const char * filename, const char * mode ); >>>> >>>> It is not immediately clear whether that can fail. Sure, we can make >>>> that inference, based on what we know about filesystems, etc., but the >>>> compiler is never going to complain if I ignore the possibility. >>>> >>>> In my experience, programmers in many languages end up resorting to >>>> convention to try and work around these sorts of ambiguities. Large >>>> projects have strategies for naming functions that try to pass along >>>> information out of band, or languages have a pervasive culture of "lint" >>>> tools that try to use heuristics to make up for what the type system >>>> doesn't make simple. >>>> >>>> That said, I know that doing Maybe sorts of things in languages that >>>> don't have, say, pattern matching, or the idea of a "failure monad", >>>> gets to be a drag very quickly---manually unwrapping things is at best >>>> awkward, having to re-wrap them just to unwrap them again in a sequence >>>> of computations quickly leads one to believe "it's just not worth >>>> it"---or you resort to exception handling, which has its own challenges >>>> to do well. >>>> >>>> Mike. >>>> >>> >>> >>> _______________________________________________ >>> Beginners mailing list >>> Beginners(a)haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners >>> >>> >> >

6 8

Writing a Parser with attoparsec that reads from a list of tokens
by Norbert Melzer 27 Mar '15

27 Mar '15

Hi there! I want to write some small toy language using attoparsec. So I thought, first step tokenize. Let attoparsec consume the input stream and produce a list of tokens. Second step, parse tokens and produce the AST. Using parsec this would be possible easily and is documented. But I want to use attoparsec for this task, because I am interested in attoparsecs capability to have the input in chunks. TIA Norbert

3 2

ap = liftM2 id
by martin 26 Mar '15

26 Mar '15

Hello all, can someone explain ap = liftM2 id to me? liftM2 wants a binary funcation liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r but id is unary. How does this work?

4 4

Maybe and Just
by Shishir Srivastava 26 Mar '15

26 Mar '15

Hi, After reading and re-reading the haskell tutorials I don't happen to see a very convincing or appealing reason for having these data types. Can anyone please explain where Maybe and Just provide the sort of functionality that cannot be achieved in other languages which don't have these kind. Thanks, Shishir Srivastava

11 11

Something like pydoc?
by Mike Meyer 26 Mar '15

26 Mar '15

Python had the "pydoc" command, which would could be used to print a module's docstings from the command line, and provided the "help" function in the REPL. Clojure has "doc" in the REPL, at least if you told it where the sources were. I can't seem to find anything like that for Haskell - either at the command line or in ghci. Does such exist? Is such possible? Thanks, <mike

2 2

Monoids and Groups
by Shishir Srivastava 26 Mar '15

26 Mar '15

Hi, Reading about Monoids it seems they derive a lot on the algebraic structures of 'Groups' ? Is it then correct to assume that Monoids can be used to represent 'Groups' ? If not are there any standard haskell libraries which represent algebraic structures such as 'Groups' , 'Fields' etc. Thanks, Shishir Srivastava

3 2

Empty list
by Shishir Srivastava 26 Mar '15

26 Mar '15

Hi, Can someone please explain why this results in error - [] `elem` [1,2,3] Shouldn't the empty set by definition be the element of all sets including a non-empty set ? I am assuming 'Lists' are different from 'Sets' in Haskell, if yes, is there a separate module for dealing/working with sets ? Thanks, Shishir Srivastava

7 7

Type Parameters and Type Variables
by Shishir Srivastava 26 Mar '15

26 Mar '15

What's the difference between the two.. ? Shishir Srivastava

2 1

parsec and a never terminating parser
by Adam Flott 25 Mar '15

25 Mar '15

I'm having trouble understanding why my simple parser never terminates when specific input is used. For example, let's say the first column is a field which can be in one of 4 states, empty, omitted, other, and any arbitrary value. That is, data FieldState a = EmptyState | OmittedState | OtherState | FullState a deriving (Eq, Ord) When attempting to use, $ echo "- " | ./parser "- \n" empty ('-') $ echo "^ " | ./parser "^ \n" omitted ('^') $ echo "~ " | ./parser "~ \n" other ('~') [ all of this is as expected ] $ echo "1 " | ./parser "1 \n" [ computer twiddles it's thumbs here until I manually terminate it ... ] ^C^C $ Does anyone know what's happening and now to alleviate it? -- begin full code -- -- base import Control.Applicative import Data.Word -- Hackage import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.IO as TLIO import Text.Parsec (parse) import Text.Parsec.Text.Lazy (Parser) import Text.Parser.Combinators import Text.Parser.Char data FieldState a = EmptyState | OmittedState | OtherState | FullState a deriving (Eq, Ord) instance Functor FieldState where fmap f (FullState a) = FullState (f a) fmap _ EmptyState = EmptyState fmap _ OmittedState = OmittedState fmap _ OtherState = OtherState instance Applicative FieldState where pure = FullState (FullState f) <*> (FullState x) = FullState (f x) _ <*> _ = EmptyState instance Monad FieldState where (FullState x) >>= k = k x EmptyState >>= _ = EmptyState OmittedState >>= _ = OmittedState OtherState >>= _ = OtherState (FullState _) >> k = k EmptyState >> _ = EmptyState OmittedState >> _ = OmittedState OtherState >> _ = OtherState return = FullState fail _ = EmptyState instance Show (FieldState x) where show (EmptyState) = "empty ('-')" show (OmittedState) = "omitted ('^')" show (OtherState) = "other ('~')" show x' = show x' data Counter = Counter Word64 deriving (Eq, Ord, Show) parseNum :: (Num a) => Parser a parseNum = do n <- rd <$> many digit return $ fromIntegral n where rd = read :: String -> Integer parseCounter :: Parser Counter parseCounter = Counter <$> parseNum parseFieldStateOff :: Parser Char parseFieldStateOff = char '-' parseFieldStateOmitted :: Parser Char parseFieldStateOmitted = char '^' parseFieldStateOther :: Parser Char parseFieldStateOther = char '~' parseFieldState :: Parser a -> Parser (FieldState a) parseFieldState p = (parseFieldStateOff >> return EmptyState) <|> (parseFieldStateOmitted >> return OmittedState) <|> (parseFieldStateOther >> return OtherState) <|> (p >>= return . FullState) main :: IO () main = do ls <- TLIO.getContents print ls mapM_ processLine (TL.lines ls) processLine :: TL.Text -> IO () processLine line = case (parse (parseFieldState parseCounter) "" line) of Left err -> print err Right xs -> print xs

2 2

Open-ended list comprehension
by martin 25 Mar '15

25 Mar '15

Hello all, when I write my own recursions, I often end up with something like a : b : c : (f x) where f x returns a list. I assume this avoids the costly (++) function, right? But when I use list comprehensions I always get a complete list and it is costly to append something to it. How can I use the power of list comprehensions, but return an [a]->[a] instead of an [a]? Is this a good idea at all, or will I pile up thunks?

3 3