[Java] Domain Specific Languages, Martin Fowler ed esperimenti

[shinya]

Leggendo un pò il work in progress sui DSL di Fowler, e cercando di impadronirmi delle tecniche che descrive, ho buttato giù un piccolo DSL per cominciare a gestire le collections standard Java attraverso un'interfaccia cosidetta 'fluent'.

Questo è un esempio di come si potrebbero utilizzare le liste in java:

import static it.fluent.builders.ListBuilderHelper.list;
import static java.lang.System.out;

public class FluentTest {

  public static void main(String[] args) {
    list("I", "can", "has", "cheezburger", "plz", "?")
      .shuffle()
      .sort()
      .reverse()
      .println(out);
  }
}

Sembra quasi un linguaggio dinamico, e invece è puro Java 100%, con type check a compile time, il framework e tutto quanto.

Le classi che ci stanno dietro sono molto semplici (per il momento...ma questo è solo un esercizio di stile):

package it.fluent.builders;

import java.util.Arrays;

public class ListBuilderHelper {
  public static <T extends Comparable<? super T>> ListBuilder<T> list(T ... elements) {
    return new ListBuilder<T>(Arrays.asList(elements));
  }
}


package it.fluent.builders;

import java.io.PrintStream;
import java.util.Collections;
import java.util.List;

public class ListBuilder<T extends Comparable<? super T>> {
  private List<T> list = null;
  
  public ListBuilder(List<T> list) {
    this.list = list;
  }
  
  public List<T> get() {
    return list;
  }
  
  public ListBuilder<T> sort() {
    Collections.sort(list);
    return this;
  }
  
  public ListBuilder<T> reverse() {
    Collections.reverse(list);
    return this;
  }
  
  public ListBuilder<T> shuffle() {
    Collections.shuffle(list);
    return this;
  }
  
  public void println(PrintStream out) {
    out.println(list.toString());
  }
}

Non so se avete già letto gli stralci del libro che Fowler ha pubblicato sul suo sito, ma l'approccio mi sembra quantomeno interessante (anche se non credo sia la panacea di tutti i mali, come anche l'autore specifica) e credo meriti uno studio più approfondito.

Altro materiale si trova sul sito di Fowler, e precisamente qua:
http://martinfowler.com/dslwip/

Che ne pensate di questo approccio?

[shinya]

Ok, magari non interessa niente a nessuno, ma ci ho lavorato un pochino su...adesso ho un piccolo DSL per fare qualcosa di più serio.
Ho aggiunto una map per applicare una funzione al volo a una lista, una funzione range stile python e qualche altre cosina wrappando la libreria standard.

import static it.jfluent.builders.ListBuilderHelper.*;
import static it.jfluent.builders.RangeBuilderHelper.*;
import static java.lang.System.*;

import it.jfluent.builders.Function;

public class FluentTest {
  public static void main(String[] args) {
    out.println("Test1"); test1();
    out.println();
    out.println("Test2"); test2();
    out.println();
    out.println("Test3"); test3();
    out.println();
    out.println("Test4"); test4();
  }
	
  private static void test4() {
    list(range('A','Z'))
      .println(out);
	  
    list(range(1,10))
       .println(out);
  }

  private static void test3() {
    list(0,1,2,3,4,5,6,7,8,9)
      .println(out)
      .map(new Function<Integer, Integer>() {
        public Integer apply(Integer elem) {
          return elem.intValue() + 1;
        }
      })
      .println(out)
      .mapCopy(new Function<Integer, String>() {
        public String apply(Integer elem) {
          return elem.toString() + " -> is string now!";
        }
      })
      .println(out);
  }
	
  private static void test2() {
    list(0,1,2,3,4,5,6,7,8,9)
      .shuffle()
      .println(out)
      .map(new Function<Integer, Integer>() {
        public Integer apply(Integer elem) {
          return elem.intValue() + 1;
        }
      })
      .println(out);
  }

  private static void test1() {
    list("I", "can", "has", "cheezburger", "plz", "?")
      .shuffle()
      .sort()
      .println(out)
      .reverse()
      .println(out)
      .map(new Function<String, String>() {
        public String apply(String elem) {
          return "LOL " + elem;
        }
      })
      .println(out);
  }
}

Output:

Test1
[?, I, can, cheezburger, has, plz]
[plz, has, cheezburger, can, I, ?]
[LOL plz, LOL has, LOL cheezburger, LOL can, LOL I, LOL ?]

Test2
[9, 8, 6, 4, 2, 5, 3, 0, 1, 7]
[10, 9, 7, 5, 3, 6, 4, 1, 2, 8]

Test3
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1 -> is string now!, 2 -> is string now!, 3 -> is string now!, 4 -> is string now!, 5 -> is string now!, 6 -> is string now!, 7 -> is string now!, 8 -> is string now!, 9 -> is string now!, 10 -> is string now!]

Test4
[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Questa è solo la classe di test ovviamente... se a qualcuno interessano i sorgenti posso postarli.

Nessuno ha niente da dire su quest'approccio? Impressioni?

[TuX2K6]

Sembra piuttosto interessante e se metti anche il codice base domani me lo guardo con calma da lavoro
Lavorare così sulle collection sembra comodo, domani darò una letta anche al link

[fek]

Originariamente inviato da shinya

Leggendo un pò il work in progress sui DSL di Fowler, e cercando di impadronirmi delle tecniche che descrive, ho buttato giù un piccolo DSL per cominciare a gestire le collections standard Java attraverso un'interfaccia cosidetta 'fluent'.

Questo è un esempio di come si potrebbero utilizzare le liste in java:

import static it.fluent.builders.ListBuilderHelper.list;
import static java.lang.System.out;

public class FluentTest {

  public static void main(String[] args) {
    list("I", "can", "has", "cheezburger", "plz", "?")
      .shuffle()
      .sort()
      .reverse()
      .println(out);
  }
}

Sembra quasi un linguaggio dinamico, e invece è puro Java 100%, con type check a compile time, il framework e tutto quanto.

E' uno stile che mi piace moltissimo, perche' comunica molto bene. Quando riesco a modellare qualcosa cosi', lo faccio anche in C++. Il rischio e' farsi prendere un po' la mano e complicarsi la vita.

E' uno strumento, e in certe situazioni funziona molto ma molto bene.

[^TiGeRShArK^]

a me invece non piace molto questo....
Gli esempi di Fowler mi piacevano di +
Comunque è un pò overkill per i miei gusti crearsi un linguaggio per risolvere dei problemi di uno stesso dominio...
A meno che non si sa già a priori il tipo dei problemi che si dovranno affrontare e che i problemi siano prevelentemente quelli, che ora come ora non è il mio caso.
ah... perchè non è stato fatto lo static import di java.lang.System.out ma solo di java.lang.System.*?
personalmente ritengo + leggibile println() di out.println()...

[thebol]

[quote=^TiGeRShArK^;22071662]a me invece non piace molto questo....
Gli esempi di Fowler mi piacevano di +
Comunque è un pò overkill per i miei gusti crearsi un linguaggio per risolvere dei problemi di uno stesso dominio...
A meno che non si sa già a priori il tipo dei problemi che si dovranno affrontare e che i problemi siano prevelentemente quelli, che ora come ora non è il mio caso.
ah... perchè non è stato fatto lo static import di java.lang.System.out ma solo di java.lang.System.*?
personalmente ritengo + leggibile println() di out.println()... [/QUOi
TE]

lo scopo e di avere un linguaggio con termini più vicini al business/dominio, in modo da poter far vedere il codice a un esperto di dominio(senza un background informatico) senza dover tradurre.

C'è chi in java rimpiange nn aver fatto ritornare ai metodi void l'oggetto stesso, in modo da avere metodi fluent a gratis(c'era anche un JSR per questo, ma la vedo dura che arriverà mai in porto)

[shinya]

Originariamente inviato da ^TiGeRShArK^

a me invece non piace molto questo....
Gli esempi di Fowler mi piacevano di +
Comunque è un pò overkill per i miei gusti crearsi un linguaggio per risolvere dei problemi di uno stesso dominio...
A meno che non si sa già a priori il tipo dei problemi che si dovranno affrontare e che i problemi siano prevelentemente quelli, che ora come ora non è il mio caso.
ah... perchè non è stato fatto lo static import di java.lang.System.out ma solo di java.lang.System.*?
personalmente ritengo + leggibile println() di out.println()...

Beh partendo dal presupposto che i gusti son gusti, e che anch'io ritenga che quest'approccio abbia i suoi bei limiti, il mio tentativo ha come scopo quello di cercare di capire come funzionano le tecniche che descrive Fowler scrivendo qualcosa che forse mi può tornare utile. Forse, ripeto, perchè è solo un esperimento.

Sul fatto che sia overkill ti posso dare abbastanza ragione se ci si fa prendere troppo la mano (la funzione println() ad esempio non so se la metterei in una release...la usavo come debug per vedere come veniva modificata la lista). Sul discorso del dominio...beh non è detto che sia lo stesso dominio (non ho capito di cosa poi) perchè questo piccolo DSL che ho fatto serve solo per maneggiare collections (in particolare liste, per ora, ma credo di aver voglia di sperimentare anche con altro).

Sullo static import di System: adesso è come dici tu, era stato l'"organize imports" di eclipse ad averlo impostato cosi. Comunque è una cosa in fase embrionale...ci sono una manciata di classi, di puntini sulle 'i' ce ne sarebbero da mettere! :P
E poi l'esempio nel primo post non è più da guardare, lo stato della "libreria" aggiornato è nel secondo post.

Per chi era interessato ai sorgenti, sono in allegato... ma ripeto, non ha nessuna pretesa di completezza e non è production-ready (mancano dei seri test...è una bozza...non so più come dirlo! :P)

[shinya]

Beh alla fine ho messo il tutto in un progetto su google code.

La libreria può essere scaricata da qui: http://code.google.com/p/jfluent/
Ovviamente ci sono anche i sorgenti in svn e tutto quanto.
E' tutto in alpha ovviamente! Devo scrivere test seri, ecc..ecc...

Comunque ora c'è il supporto a tutte le funzionalità di java.util.List e java.lang.String + java.lang.StringBuilder (sempre che non mi sia dimenticato qualcosa).

In homepage c'è un esempio di come può essere utilizzata. Mi piacerebbe sentire opinioni, suggerimenti e critiche varie ed eventuali...