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. Call for Participation: Summer School on Advanced Functional
Programming (Alejandro Serrano Mena)
2. Re: Efficient Binary Multiplication (Steven Leiva)
----------------------------------------------------------------------
Message: 1
Date: Mon, 16 Apr 2018 15:26:20 +0200
From: Alejandro Serrano Mena <trup...@gmail.com>
To: haskell-cafe <haskell-c...@haskell.org>, beginners@haskell.org
Subject: [Haskell-beginners] Call for Participation: Summer School on
Advanced Functional Programming
Message-ID:
<cahnfxotm7v5tdefr7c53wxdh+9fzro5saxh9fbudjo8gnn3...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
# Call for Participation
SUMMER SCHOOL ON ADVANCED FUNCTIONAL PROGRAMMING
Utrecht, the Netherlands, 27-31 August 2018
http://www.afp.school
## ABOUT
The Advanced Functional Programming summer school has been running for
more than ten years. We aim to educate aspiring Haskell programmers
beyond the basic material covered by many textbooks.
The lectures will cover several more advanced topics regarding the
theory and practice of Haskell programming, including topics such as:
* lambda calculus;
* monads and monad transformers;
* lazy evaluation;
* generalized algebraic data types;
* type families and type-level programming;
* concurrency and parallelism.
The summer school consists of a mix of lectures, labs, and a busy
social program.
## LECTURERS
Utrecht staff:
* Johan Jeuring
* Alejandro Serrano Mena
* Doaitse Swierstra
* Wouter Swierstra
Guest lectures:
* Manuel Chakravarty
* Koen Claessen
* Gabriele Keller
## PREREQUISITES
We expect students to have a basic familiarity with Haskell
already. You should be able to write recursive functions over
algebraic data types, such as lists and trees. There is a great deal
of material readily available that covers this material. If you’ve
already started learning Haskell and are looking to take your
functional programming skills to the next level, this is the course
for you.
## DATES
Registration deadline: 1 August, 2017
School: 27-31 August
## COSTS
€1700 - Housing and registration
€1500 - Registration only
We offer a €1000 discount for students and staff members affiliated with
a university.
## SCHOLARSHIPS
If you’re struggling to finance your trip to Utrecht, please let us
know. We have a limited number of scholarships or discounts available
for students that would not be able to attend otherwise, especially
for women and under represented minorities.
## FURTHER INFORMATION
Further information, including instructions on how to register, is
available on our website:
http://www.afp.school
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20180416/b6a88a6f/attachment-0001.html>
------------------------------
Message: 2
Date: Mon, 16 Apr 2018 20:48:40 -0400
From: Steven Leiva <leiva.ste...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Efficient Binary Multiplication
Message-ID:
<CA+=woS7=h4mc4bj-r6b51z_s37xwpndjedrzkdd9+uyzqxa...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Interesting question.
So there is a concept in computer science called *fusion*.
My understanding (I don't have a CS degree) is that when data is subject to
fusion, we don't create the intermediary lists as you are talking about.
This is why, in Haskell, we have the *ByteString* and *Text* datatypes.
Unlike *String*, they (ByteString / Text) are subject to fusion. *Text* is
useful when we are dealing with unicode data, while *ByteString* is the
correct tool when we are dealing with binary data.
All of this is to say that you should look at the *ByteString* data type.
(Take a look at this description, for example:
https://hackage.haskell.org/package/bytestring-0.10.8.2/docs/Data-ByteString.html#t:ByteString).
The only potential problem I see is that *ByteString* internally uses
*Word8*, and since *Word8* is *unsigned*, negatives are problematic. (Now
that I think about it, how the heck do you represent negative numbers in
binary?).
I hope this is useful.
On Sat, Apr 14, 2018 at 4:28 PM, Quentin Liu <quentin.liu.0...@gmail.com>
wrote:
> Hi all,
>
> Suppose I want to multiply two binary numbers whose representation uses
> lists (e.g. 14 is represented as [1, 1, 1, 0]). Is there any efficient way
> to do binary multiplication? The way I could come up with involves a lot of
> intermediate lists that will be discarded eventually and is extremely
> inefficient. I know one fast algorithm that uses Array but would it be
> possible to do the multiplication with only lists?
>
> Regards,
> Qingbo Liu
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
--
Steven Leiva
305.528.6038
leiva.ste...@gmail.com
http://www.linkedin.com/in/stevenleiva
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20180416/79305639/attachment-0001.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 118, Issue 11
******************************************
