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
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 <borgauf@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
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 <toad3k@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 <borgauf@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
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 <borgauf@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 <toad3k@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 <borgauf@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
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 <toad3k@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 <borgauf@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 <toad3k@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 <borgauf@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
You can, you have to write it slightly differently. But defined that way it can only ever have one element because NList only takes one. mylist = NList (NList (NList (Elem 1))) You could also change it to data NestedList a = Elem a | NList a (NestedList a) But at that point you have a nonempty list type (always at least one element) which already exists. On Tue, Jan 26, 2021, 17:40 Lawrence Bottorff <borgauf@gmail.com> wrote:
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 <toad3k@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 <borgauf@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 <toad3k@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 <borgauf@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
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
participants (2)
-
David McBride -
Lawrence Bottorff