September 2021 - Beginners

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

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