Brian Bilston has written a [History of Modern Art in Poetry](https://brianbilston.com/2017/07/01/a-history-of-modern-art-in-poetry/). I wondered what it would be like to do something similar in various programming languages.
Here's the original poem:
> Roses are red Violets are blue Sugar is sweet And so are you
# Haskell
Here’s the poem constructed using a zip statement in Haskell
```haskell
Prelude> zip ["roses","violets","sugar","you"]["red","blue","sweet","sweet"]
[("roses","red"),("violets","blue"),("sugar","sweet"),("you","sweet")]
```
The list produced holds the relationship that sugar is sweet and you are sweet. The comparison between "you" and sugar is not made clear.
# Lisp
Here's the poem stored as an alist in Lisp
```lisp
(setq poem '(("roses" . "red") ("violets" . "blue") ("sugar" . "sweet")("you" . "sweet")))
(mapcar (lambda (x) (concat (car x) " are " (cdr x))) poem)
```
I've gone one stage further here, using a mapcar function to produce something that looks a little bit more like the original poem, however we're still missing the connection between "you" and sugar.
`("roses are red" "violets are blue" "sugar are sweet" "you are sweet")`
# Python
Of course, sugar are sweet isn't right. Let's try some Python.
```python
poem = {"roses":"red","violets":"blue","sugar":"sweet","you":"sweet"}
for key, value in poem.items():
if key == "sugar":
print(key, "is" ,value)
else:
print(key, "are", value)
```
This output is at least grammatically correct.
> roses are red
> violets are blue
> sugar is sweet
> you are sweet
# Java
Java can do something similar using a HashMap
```java
Map<String, String> poem = new HashMap<String, String>();
poem.put("roses", "red");
poem.put("violets", "blue");
poem.put("sugar", "sweet");
poem.put("you", "sweet");
for (Map.Entry<String, String> entry : poem.entrySet()) {
if(entry.getKey().equals("sugar")){
System.out.println(entry.getKey() + " is " + entry.getValue());
} else{
System.out.println(entry.getKey() + " are " + entry.getValue());
}
}
```
But we're still no closer to conveying the connection between "you" being sweet, just like sugar is sweet.
Fortunately, Java allows us to use some object oriented design to better convey the meaning of the poem.
In the example below I've used an interface to allow sweetness to be applied to both sugar and to the special one to whom the poem refers. The comparison is at last made clear. As there can only be one true love, it seemed reasonable to make a singleton class for TheOne, inherited from a regular person.
Run the code and the poem is printed out properly, just like the original. More importantly though, the concepts to which the poem refers are properly encapsulated and related.
The original poem was only 4 lines long. My implementation takes 80 lines, but I think you'll agree I've done a rather better job, providing clarity and removing any ambiguity.
```java
public class Love {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Flower [] rose = new Flower[12]; // 12 roses in a bunch
Flower [] violet = new Flower[30]; // more violets in bunch
Sugar sugar = new Sugar();
TheOne myLove = TheOne.getInstance(); // Singleton class
// There can only be one true love
rose[0] = new Flower();
rose[0].setColour("red"); // colour is static so only need
// to instantiate one here
violet[0] = new Flower();
violet[0].setColour("blue");
System.out.println("Roses are " + rose[0].getColour());
System.out.println("Violets are " + violet[0].getColour());
System.out.println(sugar.sweet());
System.out.println(myLove.sweet());
}
}
class Flower {
private static String colour;
public void setColour(String colour){
this.colour = colour;
}
public String getColour (){
return colour;
}
}
class Sugar implements Sweetness {
@Override
public String sweet() {
return "Sugar is sweet";
}
}
class Person {
public String sweet()
{
return "Not sweet";
}
}
class TheOne extends Person implements Sweetness{
private static TheOne instance = null;
private TheOne()
{
}
public static TheOne getInstance()
{
if(instance == null)
instance = new TheOne();
return instance;
}
@Override
public String sweet() {
return "And so are you";
}
}
interface Sweetness {
String sweet();
}
```