Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: Defined list data type compared to Haskell List
(Lawrence Bottorff)
2. Re: Defined list data type compared to Haskell List
(David McBride)
3. Re: Defined list data type compared to Haskell List
(Lawrence Bottorff)
----------------------------------------------------------------------
Message: 1
Date: Tue, 26 Jan 2021 15:49:26 -0600
From: Lawrence Bottorff <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Defined list data type compared to
Haskell List
Message-ID:
<cafahfsurabudepwquwxk0jokgqvrechwp3f8o45koogoeso...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
So NestedList is using regular List? So in
data NestedList a = Elem a | List [NestedList a]
the second data constructor List [NestedList a] we see a "regular" list
because of the square brackets?
On Tue, Jan 26, 2021 at 3:42 PM David McBride <toa...@gmail.com> wrote:
> In NestedList, the List constructor takes a regular list of NestedLists.
> Therefore when pattern matching on it you can get access to those nested
> lists. In your code, x is the first NestedList, and xs is the rest of the
> NestedLists.
>
> On Tue, Jan 26, 2021 at 4:32 PM Lawrence Bottorff <borg...@gmail.com>
> wrote:
>
>> I'm following this <https://wiki.haskell.org/99_questions/Solutions/7>
>> and yet I see this solution
>>
>> data NestedList a = Elem a | List [NestedList a] deriving (Show)
>>
>> flatten1 :: NestedList a -> [a]
>> flatten1 (Elem a ) = [a]
>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>> flatten1 (List []) = []
>>
>> What I find puzzling is this line
>>
>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>>
>> where I see
>>
>> (List (x:xs)) as an argument. How is the NestedList type also able to be
>> expressed as a normal consed list with x:xs argument? How is (:)
>> interacting with NestedList?
>>
>> LB
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210126/3f4e6f0f/attachment-0001.html>
------------------------------
Message: 2
Date: Tue, 26 Jan 2021 17:04:54 -0500
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Defined list data type compared to
Haskell List
Message-ID:
<CAN+Tr42n7LVn=u4gaqyp+tf9q9ea5xq9xggd3cs6aucsxaq...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Right that is a plain list of NestedLists. So if you were to rewrite [a]
as (Regularlist a) so to speak (not a real type), the definition of
NestedList would be List (RegularList (NestedList a)).
Keep in mind that List is a constructor, everything after it is types.
On Tue, Jan 26, 2021 at 4:50 PM Lawrence Bottorff <borg...@gmail.com> wrote:
> So NestedList is using regular List? So in
>
> data NestedList a = Elem a | List [NestedList a]
>
> the second data constructor List [NestedList a] we see a "regular" list
> because of the square brackets?
>
> On Tue, Jan 26, 2021 at 3:42 PM David McBride <toa...@gmail.com> wrote:
>
>> In NestedList, the List constructor takes a regular list of NestedLists.
>> Therefore when pattern matching on it you can get access to those nested
>> lists. In your code, x is the first NestedList, and xs is the rest of the
>> NestedLists.
>>
>> On Tue, Jan 26, 2021 at 4:32 PM Lawrence Bottorff <borg...@gmail.com>
>> wrote:
>>
>>> I'm following this <https://wiki.haskell.org/99_questions/Solutions/7>
>>> and yet I see this solution
>>>
>>> data NestedList a = Elem a | List [NestedList a] deriving (Show)
>>>
>>> flatten1 :: NestedList a -> [a]
>>> flatten1 (Elem a ) = [a]
>>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>>> flatten1 (List []) = []
>>>
>>> What I find puzzling is this line
>>>
>>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>>>
>>> where I see
>>>
>>> (List (x:xs)) as an argument. How is the NestedList type also able to be
>>> expressed as a normal consed list with x:xs argument? How is (:)
>>> interacting with NestedList?
>>>
>>> LB
>>> _______________________________________________
>>> Beginners mailing list
>>> Beginners@haskell.org
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210126/f007a42d/attachment-0001.html>
------------------------------
Message: 3
Date: Tue, 26 Jan 2021 16:39:11 -0600
From: Lawrence Bottorff <borg...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Defined list data type compared to
Haskell List
Message-ID:
<cafahfsxfe01rkd_wwfsjm4yy-ecdgmccpk944bwoauu1bhg...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Why can I not do this?
data NestedList1 a = Elem a | NList (NestedList1 a)
that is, with parens rather than square brackets, then
myList2 = (NList (Elem 1, NList (Elem 2, NList (Elem 3, Elem 4), Elem 5)))
It gives the error
<interactive>:383:18-73: error:
,* Couldn't match expected type `NestedList1 a'
with actual type `(NestedList1 Integer, NestedList1 a0)'
,* In the first argument of `NList', namely
`(Elem 1, NList (Elem 2, NList (Elem 3, Elem 4), Elem 5))'
In the expression:
(NList (Elem 1, NList (Elem 2, NList (Elem 3, Elem 4), Elem 5)))
In an equation for `myList2':
myList2
= (NList (Elem 1, NList (Elem 2, NList (Elem 3, Elem 4), Elem
5)))
,* Relevant bindings include
myList2 :: NestedList1 a (bound at <interactive>:383:1)
etc., etc.
On Tue, Jan 26, 2021 at 4:05 PM David McBride <toa...@gmail.com> wrote:
> Right that is a plain list of NestedLists. So if you were to rewrite [a]
> as (Regularlist a) so to speak (not a real type), the definition of
> NestedList would be List (RegularList (NestedList a)).
>
> Keep in mind that List is a constructor, everything after it is types.
>
> On Tue, Jan 26, 2021 at 4:50 PM Lawrence Bottorff <borg...@gmail.com>
> wrote:
>
>> So NestedList is using regular List? So in
>>
>> data NestedList a = Elem a | List [NestedList a]
>>
>> the second data constructor List [NestedList a] we see a "regular" list
>> because of the square brackets?
>>
>> On Tue, Jan 26, 2021 at 3:42 PM David McBride <toa...@gmail.com> wrote:
>>
>>> In NestedList, the List constructor takes a regular list of
>>> NestedLists. Therefore when pattern matching on it you can get access to
>>> those nested lists. In your code, x is the first NestedList, and xs is the
>>> rest of the NestedLists.
>>>
>>> On Tue, Jan 26, 2021 at 4:32 PM Lawrence Bottorff <borg...@gmail.com>
>>> wrote:
>>>
>>>> I'm following this <https://wiki.haskell.org/99_questions/Solutions/7>
>>>> and yet I see this solution
>>>>
>>>> data NestedList a = Elem a | List [NestedList a] deriving (Show)
>>>>
>>>> flatten1 :: NestedList a -> [a]
>>>> flatten1 (Elem a ) = [a]
>>>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>>>> flatten1 (List []) = []
>>>>
>>>> What I find puzzling is this line
>>>>
>>>> flatten1 (List (x:xs)) = flatten1 x ++ flatten1 (List xs)
>>>>
>>>> where I see
>>>>
>>>> (List (x:xs)) as an argument. How is the NestedList type also able to
>>>> be expressed as a normal consed list with x:xs argument? How is (:)
>>>> interacting with NestedList?
>>>>
>>>> LB
>>>> _______________________________________________
>>>> Beginners mailing list
>>>> Beginners@haskell.org
>>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> Beginners@haskell.org
>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners@haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20210126/4219ed44/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 150, Issue 15
******************************************
