|
![](/i/fill.gif) |
scott wrote:
>> Hmm, maybe I should write my own?
>
> It's very useful for an absolute beginner, these are the things you need
> to know that a lot of tutorials assume you somehow magically know already.
The hard thing about writing a tutorial is that by the time you're
experienced enough to be an authority on the language, half the stuff
that trips newbies up is so utterly "obvious" to you that you forget to
even mention it. (Plus you're all excited and you want to jabber
incoherently about the cool stuff, not the dry old "this is how you
escape a newline character".)
>> > :t fst
>> Take a look at this type signature. Can you figure out what it means?
>>
>> > fst (5, 'x')
>> Did that do what you expected?
>
> Well it seems to return the first item from a tuple.
>
> Is it just a shorthand for "take 1"?
>
> Ah no, it seems those list operators don't work with tuples :-(
It's all in the type signature.
[Int] means a list of integers. It can contain any possible number of
integers (including zero or infinity). [Char] means a list of characters.
Tuples, on the other hand, have a different type for each size, and each
combination of element types. For example, (5, 'x') is of type (Int,
Char), but (5, 'x', False) is of type (Int, Char, Bool). As far as the
type system is concerned, these two types are completely unrelated.
Because of this, you cannot write a function that works on any possible
size of tuple. It's impossible. (You can write a *method* that works for
any size of tuple that you've manually written a definition for, but
that's about it.)
In truth, if you're using tuples bigger than about three or four
elements, you really ought to define a custom type for this stuff
instead of relying on tuples. Tuples are really for simple, quick things
like returning multiple results from a function, or for key/value pairs.
Stuff like that.
...and this whole explanation is a good example of the kind of thing
that's hard to explain in an interactive tutorial. ;-)
> So this means "let x = 5 in (the following expression)..."
Indeed yes.
> Now Step 7 in the original tutorial makes sense :-)
Yeah. It's simple, it's just explained badly...
>> OK, I'm going to stop now...
>
> OK I need to download the compiler if I am to actually learn any of this...
I can talk some more if you want?
But yes, this (alpha) web thingy lacks several important features:
- You can't define things and refer to them later. Each expression is
processed independently.
- You can't write multi-line definitions.
- You can't do I/O. (And the error message if you try is cryptic to say
the least!)
- You can't use all of the standard Haskell libraries, just the handful
the interpretter offers.
In a real Haskell interpretter, you can usually do stuff like
> let factorial n = product [1..n]
> let choose n k = (factorial n) / (factorial k * factorial (n - k))
> choose 3 5
In the online interpretter, you'd have to do
> let factorial n = product [1..n]; choose n k = (factorial n) /
(factorial k * factorial (n - k)) in choose 3 5
This, coupled with the horrifyingly buggy command history, is just no
fun at all.
Are you actually interested enough to want to play with it more?
Post a reply to this message
|
![](/i/fill.gif) |