# Shaping poems: Generalisation with methods

## by Paul Curzon, Queen Mary University of London

Methods are an important way that computer scientists practice generalisation when programming. Whether you call them methods, routines, functions or procedures, they give a way to write generalised solutions to a problem rather than a one of solution that is no good for any other problem. I recently wrote a little method that was really just for fun, but illustrates some of the main ideas. It is all about printing a poem in a shape that matches a number sequence…

## A Fibonacci Poem Twitter recently doubled the number of characters allowed in tweets to 280 characters. Some think that this destroys the whole charm of tweets and the way they force conciseness. Brian Bilston tweeted this poem as a response which increases the number of words in each line according to a fibonacci number sequence. It is a famous sequence found often in nature such as in the numbers of petals on flowers and in bee breeding.  (See this cs4fn article for more) The sequence runs 1,1,2,3,5,8,13,21, … with each number obtained by adding the previous two. Brian’s poem made me think that shaping poems is a nice way to explore number sequences, so I started to play with a program.

I ended up with a really general program that could take different poems and different number sequences, but to start with I just tried to write a program that could simply print out Brian’s poem with line breaks following the fibonacci  sequence as he intended it to be formatted. Here is what I cam up with (using Python)…

First I needed to write a method that given a number n returns the nth fibonacci number. This is really easy using recursion as what you write corresponds closely to the way we described what it does in English. If n is 1 or 2 then the answer is 1, but otherwise it is the sum of the previous two fibonacci numbers. It works out those previous two fibonacci numbers using recursion – just calling the method fibonacci itself but with smaller numbers, so earlier positions in the sequence.

```def fibonacci(n):
if n == 1 :
return 1
elif n == 2 :
return 1
else :
return (fibonacci(n-1) + fibonacci(n-2))```

I can then write a method that calls that method and has the poem built in. The details of how this works don’t matter so much here as I’m focussing on generalisation – so ignore the detail if you wish.

Essentially what it does though is take the poem, and split it into a list of separate words. It then goes round a loop printing a line at a time. To do that it calculates the fibonacci number (I’ve made that bit bold below so you can see) for the line number we are up to and splits off that many words from the front of the list, joins them back in to a string and prints them. It then increases the counter that is keeping track of which words have been used, so that it is now pointing beyond those words. It then goes round the loop again to print the next line and the next …

```def printpoem():
poemtoprint = """I wrote a poem in a tweet but then each line grew to the word sum of the previous two until I began to worry  about all these words coming with such frequency because as you can see, it can be easy to run out of space when a poem gets all Fibonacci sequency"""
splitPoem = poemtoprint.split(" ")
line = 1
startword = 0
endword = 0

while endword < len(splitPoem):
currentlinelength = fibonacci(line)
endword = endword + currentlinelength
thisline = splitPoem[startword:endword]
thislinetoprint = ‘ '.join(thisline)
print(thislinetoprint)
line = line + 1
startword = startword + currentlinelength

print()```

All this method can do is print that one poem, as the poem is built in to it. We call the method

`printpoem()`

and that one poem gets formatted the right way… It can’t do any other poem.

```I
wrote
a poem
in a tweet
but then each line grew
to the word sum of the previous two
until I began to worry about all these words coming with such frequency
because as you can see, it can be easy to run out of space when a poem gets all Fibonacci sequency```

## Generalise over data

That’s fine but its a bit restrictive. I’d quite like to be able to write my own poems and turn them in to fibonacci poems. I don’t want to have to write a method for every poem I write. We need to generalise the method to work for any poem we give it. Most programming languages provide a way to do this. You provide the data they need to do their job in the form of arguments to the method. You pass the data to the method and it stores it in its own local variable, but otherwise does exactly as it did before. For my method to format poems, the data is the poem. I generalise the method over all poems, by making the poem an argument. I get rid of the assignment to the variable poemtoprint at the start and instead put the variable poemtoprint in the brackets of the header line of the method to show it is an argument. It will be given a new value each time the program calls the method.

```def printpoem(poemtoprint):
splitPoem = poemtoprint.split(" ")
line = 1
startword = 0
endword = 0

while endword < len(splitPoem):
currentlinelength = fibonacci(line)
endword = endword + currentlinelength
thisline = splitPoem[startword:endword]
thislinetoprint = ‘ '.join(thisline)
print(thislinetoprint)
line = line + 1
startword = startword + currentlinelength

print()```

With that small change, this new version of the method works for any poem to print. The poem is no longer hardwired in to the method. To get it to print the original poem, we provide the poem when we call the method by placing it in the brackets in the call as follows:

`printpoem("""I wrote a poem in a tweet but then each line grew to the word sum of the previous two until I began to worry about all these words coming with such frequency because as you can see, it can be easy to run out of space when a poem gets all Fibonacci sequency""")`

This prints the poem exactly as before. The change means, though, that if I write my own poem (ok, I know its not as good as the original) I can pass it to the method instead as follows:

`printpoem("""My poem began well, completely under control. But it got carried away. Lines grew longer, how long I couldn’t say. They took on a life of their own, until I realised at last. They were following fibonacci’s sequence which meant that once they were expanding they just kept growing in length so, so fast.”"")`

It gets formatted in the fibonacci way too – no new code needed!

```My
poem
started off
completely under control.
But it got carried away.
Lines grew longer, how long I couldn’t say.
They took on a life of their own, until I realised at last.
They were following fibonacci’s sequence which meant that once they were expanding they just kept growing in length so, so fast.```

The poem could be stored in a variable, then we just put the variable in the call eg

```mypoem = """My poem began well, completely under control. But it got carried away. Lines grew longer, how long I couldn’t say. They took on a life of their own, until I realised at last. They were following fibonacci’s sequence which meant that once they were expanding they just kept growing in length so, so fast."""

printpoem(mypoem)```

This gets the value of mypoem and passes it to printpoem.

Getting more advanced: Generalise over methods

At this point I start to get carried away. Why stop at Fibonacci poems. Why can’t we have Factorial poems, that get bigger really, really fast, or arithmetic ones, or triangular shaped poems, never mind, your common or garden rectangular shaped ones. Why should I write a new method for each! The only difference between any of them is the  number sequence. We need to generalise over the number sequence too.

In many modern languages, Python included, this isn’t a problem. You can generalise over methods. Methods themselves can be thought of as data and you can pass them as arguments to other methods. All I need to do is add another argument to the method that I will call numbersequence. It is just a variable, but one that can hold a method. The type of method it holds is one that, given a number representing a position in a sequence, returns the number found at that position in the sequence. We just need to replace the call to fibonacci that we had before with a call to whatever is stored in this variable:

```def printpoem(poemtoprint, numbersequence):
splitPoem = poemtoprint.split(" ")
line = 1
startword = 0
endword = 0

while endword < len(splitPoem):
currentlinelength = numbersequence(line)
endword = endword + currentlinelength
thisline = splitPoem[startword:endword]
thislinetoprint = ‘ '.join(thisline)
print(thislinetoprint)
line = line + 1
startword = startword + currentlinelength

print()```

To call this method, you give it a poem such as Brian’s and a method that gives a number sequence and it formats the poem according to the method.

If we call it with Brian’s poem and our fibonacci function…

```poem = """I wrote a poem in a tweet but then each line grew to the word sum of the previous two until I began to worry about all these words coming with such frequency because as you can see, it can be easy to run out of space when a poem gets all Fibonacci sequency”""

printpoem(poem, fibonacci)```

We get his poem formatted as before. However, as we now have a generalised function to solve the problem, not a specific one, we can do lots more. We can pass it other functions defining different number sequences and so print it out in different ways. For example, if I want to make the poem’s lines just increase by one word at a time in a simple triangular shape, I just need a method that returns the length of each line. That is easy as all it requires is the nice simple number sequence 1,2,3,4, … It just returns the number it is passed, as the line number gives the required length of that line.

```def righttriangle(n):
return n```

We can pass our general method my poem and this method.

`printpoem(mypoem, righttriangle)`

and the poem is automatically formatted a different way:

```My
poem started
off completely under
control. But it got
carried away. Lines grew longer,
how long I couldn’t say. They
took on a life of their own,
until I realised at last. They were following
fibonacci’s sequence which meant that once they were expanding
they just kept growing in length so, so fast.```

Of course we should really write poems that match the number sequence we are using so here is my first attempt. Writing the method was easy. The poem was a bit harder, but here goes…

```trianglepoem = "I like triangles of all types, but square cornered ones are especially right for me."

printpoem(trianglepoem,righttriangle)```

I get my formatted poem …

```I
like triangles
of all types,
but square cornered ones
are especially right for me.```

We can now print out poems in any pattern we can write the number sequence for. The simplest shape of all, where all lines are the same length, raises a new problem, though, and to solve it we will need to be more sophisticated than ever in the way we think of methods. We need something called currying, which gives an amazing amount of flexibility.

Lets suppose we want to print out a poem in a rectangular way with 5 words per line. That is easy we just need the method that takes the position n and always returns 5 whatever line we are on.

```def rectangle5 (n):
return 5```

However, we’ve just spent a lot of time praising the idea of generalisation so of course what we want really is to pass it the number of words in a line too. That’s easy. We just need two arguments.

```def rectangleN (side, n):
return side```

The trouble is this doesn’t work with our poem-printing method. It expects a single argument. Remember, how it appears in the method is:

currentlinelength = numbersequence(line)

Ours has two arguments. It doesn’t fit. It has the wrong type.

What we need is a way to pass arguments to a method one at a time. That is called currying. You give a method one argument and it gives you back a new method that takes the next argument. Some languages give nice easy ways to do that. You can do it in Python, but it looks a bit convoluted as there is no nice syntax. In fact its doing exactly as described above. You define a method inside the method.

In our case we want a method that, when passed an argument that says the number of words you want to fix each line length as, gives back a method of the kind we need. It should return a method, rectangleN, that when passed a number always returns the same number – that fixed side.

```def rectangle (words):
def rectangleN(n):
return words
return rectangleN```

So this method has a method defined in it, rectangleN, that is the specific method we want. Whatever value is passed as the first argument is the value the created method will return when called. The method as a whole returns the new method, rectangleN.

We then get the method to give to our printpoem method by calling this method with just one argument so, for example,

`rectangle(5)`

creates the specific method  we need to give the number sequence 5,5,5, …

We really need a poem about rectangles to try this out on, but my poem-writing skills are running  out of steam. So calling it on the original poem

`printpoem(poem,rectangle(5))`

gives us a more boring version of that poem (though at least this one fits on the page):

```I wrote a poem in
a tweet but then each
line grew to the word
sum of the previous two
until I began to worry