- Beginners - Haskell.org

Parsing a file
by Roger Mason 27 Jan '22

27 Jan '22

Hello, Warning: long post. I've worked my way through various parsing tutorials using either Parsec or ReadP. I reached a point where I need to try parsing one of the types of file for which I'm writing the parser. I have written parsers for various parts of this file: eqatoms.out: ====================================================== Species : 1 (Si) atom 1 is equivalent to atom(s) 1 2 3 atom 2 is equivalent to atom(s) 1 2 3 atom 3 is equivalent to atom(s) 1 2 3 Species : 2 (O) atom 1 is equivalent to atom(s) 1 2 3 4 5 6 atom 2 is equivalent to atom(s) 1 2 3 4 5 6 atom 3 is equivalent to atom(s) 1 2 3 4 5 6 atom 4 is equivalent to atom(s) 1 2 3 4 5 6 atom 5 is equivalent to atom(s) 1 2 3 4 5 6 atom 6 is equivalent to atom(s) 1 2 3 4 5 6 ====================================================== These are my imports: ====================================================== import qualified Text.Parsec as Parsec import Text.Parsec ((<?>)) import Control.Applicative import Control.Monad.Identity (Identity) ====================================================== These are my parsers: ====================================================== :{ species :: Parsec.Parsec String () (String,String) species = do --Parsec.char 'S' Parsec.string "Species" Parsec.spaces Parsec.char ':' Parsec.spaces digits <- Parsec.many1 Parsec.digit Parsec.spaces Parsec.char '(' id <- Parsec.many1 Parsec.letter return (id,digits) :} :{ atom = do Parsec.spaces Parsec.string "atom" Parsec.spaces digits <- Parsec.digit return digits :} :{ equivalents = do Parsec.spaces digits <- Parsec.digit return digits :} ====================================================== Some simple tests: ====================================================== src = "oops" Parsec.parse species src "Species : 1 (Si)" Right ("Si","1") src = "Parsing_File/eqatoms.out" Parsec.parse atom src "atom 5 is equivalent to atom(s)" Right '5' src = "Parsing_File/eqatoms.out" Parsec.parse (Parsec.many1 equivalents) src " 1 2 3 4 5 6" : Right "123456" ====================================================== So, the individual parsers work as intended. However, parsing an actual file does not work. I define a function to return the file contents: ====================================================== :{ input = do eqatoms <- readFile "Parsing_File/eqatoms.out" return eqatoms :} ====================================================== A test shows that my reader works: ====================================================== input : Species : 1 (Si)\n atom 1 is equivalent to atom(s)\n 1 2 3\n atom 2 is equivalent to atom(s)\n 1 2 3\n atom 3 is equivalent to atom(s)\n 1 2 3\n\nSpecies : 2 (O)\n atom 1 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 2 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 3 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 4 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 5 is equivalent to atom(s)\n 1 2 3 4 5 6\n atom 6 is equivalent to atom(s)\n 1 2 3 4 5 6\n ====================================================== I attempt to parse the input: ====================================================== :{ main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return :} Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| Prelude Parsec Text.Parsec Control.Applicative Control.Monad.Identity| <interactive>:250:3: error: ,* Couldn't match type `Either Parsec.ParseError' with `IO' Expected type: IO (String, String) Actual type: Either Parsec.ParseError (String, String) ,* In a stmt of a 'do' block: Parsec.parse species "test species" eqatoms In the expression: do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return In an equation for `main': main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return <interactive>:251:3: error: ,* Couldn't match expected type `IO b' with actual type `a0 -> m0 a0' ,* Probable cause: `return' is applied to too few arguments In a stmt of a 'do' block: return In the expression: do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return In an equation for `main': main = do eqatoms <- readFile "Parsing_File/eqatoms.out" Parsec.parse species "test species" eqatoms return ,* Relevant bindings include main :: IO b (bound at <interactive>:248:3) ====================================================== Can someone please help me to get this to work? Thanks for reading to the end of this very long post. Roger

3 6

Coercing existential according to type-level Maybe
by Dmitriy Matrosov 30 Dec '21

30 Dec '21

Hi. I've tried to write a function to coerce existential value according to type stored in type-level 'Maybe' (i.e. 'Just or 'Nothing). > {-# LANGUAGE DataKinds #-} > {-# LANGUAGE RankNTypes #-} > {-# LANGUAGE KindSignatures #-} > {-# LANGUAGE PolyKinds #-} > {-# LANGUAGE TypeFamilies #-} > {-# LANGUAGE GADTs #-} > > import Data.Kind > import Data.Proxy > import Unsafe.Coerce > > class FromTypeMaybe k where > type ToType k > fromTypeMaybe :: (a -> ToType k) -> Proxy k -> a -> Maybe (ToType k) > > instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where > type ToType 'Nothing = t > fromTypeMaybe f _ x = Nothing > > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe Type) where > type ToType ('Just t) = t > fromTypeMaybe f _ x = Just (f x) > > data Any where > Any :: a -> Any > > unAny :: Any -> t > unAny (Any x) = unsafeCoerce x This works as far as i can see *Main> fromTypeMaybe unAny (Proxy @('Just Int)) (Any 3) Just 3 *Main> fromTypeMaybe unAny (Proxy @'Nothing) undefined Nothing but i don't understand how 'Nothing instance works: type kind kind? vvv vvvvvv vvv instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where type ToType 'Nothing = t ^^^ type (in case alignment breaks: variable 't' in forall is type-variable with kind 'Type', but in "Maybe t" in instance head it's used as kind-variable. And then in associated type-family the same variable 't' is used as type-variable again). If i try to write "'Nothing"'s kind as 'Maybe Type' (in the same manner as 'Just has) instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where i get an error: 1.lhs:21:3: error: • Type variable ‘t’ is mentioned in the RHS, but not bound on the LHS of the family instance • In the type instance declaration for ‘ToType’ In the instance declaration for ‘FromTypeMaybe ('Nothing :: Maybe Type)’ | 21 | > instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe Type) where | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^... Well, i'm not sure, that understand why 'forall' in instance head may not be used as family's LHS, but.. that's probably ok. On the other hand, if i try to write 'Just instance using type-variable 't' as kind-variable (in the same manner as 'Nothing has): instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where i get an error too: 1.lhs:25:47: error: • Expected kind ‘Maybe t’, but ‘'Just t’ has kind ‘Maybe *’ • In the first argument of ‘FromTypeMaybe’, namely ‘('Just t :: Maybe t)’ In the instance declaration for ‘FromTypeMaybe ('Just t :: Maybe t)’ | 25 | > instance forall (t :: Type). FromTypeMaybe ('Just t :: Maybe t) where Well, that's also probably expected, because though i've declared type-variable 't' with kind 'Type' in forall, due to 'DataKinds' extension type 't' is also promoted to kind 't' and, thus, by using ('Just t :: Maybe t) i say, that ('Just t) should have kind 'Maybe t', not 'Maybe Type', which it really has. But if that's so, how working 'Nothing instance instance forall (t :: Type). FromTypeMaybe ('Nothing :: Maybe t) where may work at all? It has the same problem as 'Just instance above: type-variable 't' is promoted to kind 't' and 'Nothing will have kind 'Maybe t' instead of 'Maybe Type' ?

2 1

Confusing Show/print error
by Galaxy Being 28 Dec '21

28 Dec '21

I've got this import Data.Tuple fswp :: (a, b) -> (b, a) fswp = Data.Tuple.swap and get this • No instance for (Show ((a0, b0) -> (b0, a0))) arising from a use of ‘print’ (maybe you haven't applied a function to enough arguments?) • In a stmt of an interactive GHCi command: print it Not sure why or what to do to correct it. ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

9 10

Non-exhaustive patterns
by Galaxy Being 12 Dec '21

12 Dec '21

This code myTakePM :: Int -> [a] -> [a] myTakePM 0 _ = [] myTakePM n (x:xs) = x : myTakePM (n-1) xs is bad because it allows myTakePM 4 [1,2,3] [1,2,3*** Exception: <interactive>:(395,1)-(396,41): Non-exhaustive patterns in function myTakePM I knew it would not work, but why is it calling this essentially a partial function? How does it know this? Again, I expected an error, but what is this Non-exhaustive patterns in function myTakePM saying? Or, said another way, what exactly is non-exhaustive about this? -- ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 2

Re: [Haskell-beginners] Beginners Digest, Vol 161, Issue 1
by Michael Turner 12 Dec '21

12 Dec '21

Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry On Sun, Dec 12, 2021 at 8:48 PM <beginners-request(a)haskell.org> wrote: > have another look at > https://hackage.haskell.org/packaggetCallStackgetCallStacke/base-4.16.0.0/d… > <https://hackage.haskell.org/package/base-4.16.0.0/docs/GHC-Stack.html#v:cal…> I'd been looking at that already, over and over. Still not seeing it. But your proposed fix does work. Thank you. > let l = getCallStack callStack > print (length l) > ``` > the `getCallStack` does not return an "IO" value.. And yet it's it's somehow an IO value in "print (length (getCallStack callStack))"? I just don't get this. > On Sun, Dec 12, 2021, 12:58 Michael Turner <michael.eugene.turner(a)gmail.com> > wrote: > > > The following prints 1, as you'd expect: > > ----------------- > > import GHC.Stack > > > > foo :: HasCallStack => IO () > > foo = do > > print (length (getCallStack callStack)) > > > > main = > > foo > > ------------------- > > But when I make it this: > > ... > > l <- getCallStack callStack ; > > print (length l) > > > > I get all this: > > ------------------------------------------ > > ... > > • Couldn't match type ‘[]’ with ‘IO’ > > Expected type: IO ([Char], SrcLoc) > > Actual type: [([Char], SrcLoc)] > > • In a stmt of a 'do' block: l <- getCallStack callStack > > In the expression: > > do l <- getCallStack callStack > > print (length l) > > In an equation for ‘foo’: > > foo > > = do l <- getCallStack callStack > > print (length l) > > | > > 5 | l <- getCallStack callStack ; > > | ^^^^^^^^^^^^^^^^^^^^^^ > > -------------------------------------------- > > > > What am I not seeing? > > > > > > Regards, > > Michael Turner > > Executive Director > > Project Persephone > > 1-25-33 Takadanobaba > > > > Shinjuku-ku Tokyo 169-0075 > > Mobile: +81 (90) 5203-8682 > > turner(a)projectpersephone.org > > > > Understand - http://www.projectpersephone.org/ > > Join - http://www.facebook.com/groups/ProjectPersephone/ > > Donate - http://www.patreon.com/ProjectPersephone > > Volunteer - https://github.com/ProjectPersephone > > > > "Love does not consist in gazing at each other, but in looking outward > > together in the same direction." -- Antoine de Saint-Exupéry

2 3

But I just want a function that returns stack depth!
by Michael Turner 12 Dec '21

12 Dec '21

The following prints 1, as you'd expect: ----------------- import GHC.Stack foo :: HasCallStack => IO () foo = do print (length (getCallStack callStack)) main = foo ------------------- But when I make it this: ... l <- getCallStack callStack ; print (length l) I get all this: ------------------------------------------ ... • Couldn't match type ‘[]’ with ‘IO’ Expected type: IO ([Char], SrcLoc) Actual type: [([Char], SrcLoc)] • In a stmt of a 'do' block: l <- getCallStack callStack In the expression: do l <- getCallStack callStack print (length l) In an equation for ‘foo’: foo = do l <- getCallStack callStack print (length l) | 5 | l <- getCallStack callStack ; | ^^^^^^^^^^^^^^^^^^^^^^ -------------------------------------------- What am I not seeing? Regards, Michael Turner Executive Director Project Persephone 1-25-33 Takadanobaba Shinjuku-ku Tokyo 169-0075 Mobile: +81 (90) 5203-8682 turner(a)projectpersephone.org Understand - http://www.projectpersephone.org/ Join - http://www.facebook.com/groups/ProjectPersephone/ Donate - http://www.patreon.com/ProjectPersephone Volunteer - https://github.com/ProjectPersephone "Love does not consist in gazing at each other, but in looking outward together in the same direction." -- Antoine de Saint-Exupéry

2 1

Looking for training
by Pratap Pachipulusu 20 Oct '21

20 Oct '21

Hello Members, Could you please suggest good haskell resources to start learning from scratch. I would love to be on top of it. Thanks, Pratap P.

5 9

Type signatures returned with :t
by Galaxy Being 19 Sep '21

19 Sep '21

> :t Just True Just True :: Maybe Bool > :t Left True Left True :: Either Bool b > :t Right False Right False :: Either a Bool What am I being told here? It seems data Maybe a = Just a | Nothing data Either a b = Left a | Right b are both straightforward parameterized types, but Maybe doesn't give me a type parameter back, while Either does, and in different order, different names (a becomes b; b becomes a) depending on which variable I invoke. What deeper lore am I not seeing here? -- ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

5 6

Re: [Haskell-beginners] A one- or two-page diagram of how Haskell works?
by Anthony Clayden 16 Sep '21

16 Sep '21

Thank you Tarik, you're spot-on correct. > It's better to try to model execution using lambda calculus. > The most dominant factor in languages like Haskell is lambda calculus. > Think through lambda calculus for a mental model. I presume it's this advice that Michael is complaining about in his long comment on the cafe yesterday. In particular, Haskell is unusual even amongst functional programming languages in its lazy evaluation. So to try to correct Michael's misunderstanding: >> When I write C, or even C++, I have a mental model of how execution will proceed. Firstly, 'execution' in Haskell does not proceed in anything like the sequence-of-steps and update-of-locations/frame-on-the-stack of C or C++ (or Fortran or ALGOL or COBOL or ...). In particular, 'variables' in Haskell are not overwritable locations in the sense of a procedural language. Variables are just a name for an expression (might be a lambda expression). This is what we mean by 'referential transparency' that procedural languages do not have. We can replace any variable by the expression it denotes, or by any other equivalent expression. Secondly, there's an important theorem (Church-Rosser) in Lambda calculus [see wikipedia], that if Beta-reduction terminates, it'll produce the same 'reduced form' of the initial expression whether it proceeds inside-out or outside-in or both-sides-to-the-middle. You don't need to second-guess how the compiler proceeds, because you don't need to know. You do need to understand Beta-reduction (that's easy). You also need to understand why Alpha-renaming is needed hand-in-hand with Beta-reduction (not so easy, but work a few examples with a recursive function, such as stepping through a list). And you need to stop immediately trying to imagine Haskell semantics as some sort of crazy Turing machine: you'll go mad. Turing himself [1937] proved the semantics are equivalent; but that paper is impenetrable for ordinary mortals like me.

1 0

Explanation of elem data type
by Galaxy Being 03 Aug '21

03 Aug '21

According to this <http://zvon.org/other/haskell/Outputprelude/elem_f.html> elem is Eq a => a -> [a] -> Bool but according to my ghci :t it's this elem :: (Foldable t, Eq a) => a -> t a -> Bool I understand the first, but not the second, especially with the t. What is this saying extra, different from the first one? ⨽ Lawrence Bottorff Grand Marais, MN, USA borgauf(a)gmail.com

3 4