:morning:

buon-tea

namaste

ciao ciao

non mi ricordo, c'è qualcuno qua che vive a berlino?

Problemino del giorno. Scrivere un XSD schema to core.spec translator…

Idea di base: parse XML, match su XSD nodes, multimethod dispatch, output specs…

Mi sembra l’approccio giusto

sono sicuro che ci saranno problemini vari da risolvere…. :fearful:

Dipende da quanto è matto il tuo schema. Noi facciamo XSD -> Haskell types, e ci bastano ~100 linee di js

Nel nostro caso lo schema è semplice

pensavo piu’ al problema generale… qualunque schema to core.spec

ma partire col caso particolare e’ opportuno

Dipende quanto è one-off la questione, noi abbiamo bisogno di eseguire/sistemare lo script ogni 2-3 mesi, quindi ha senso farlo sul caso particolare

Se devi farlo ogni giorno su cose diverse allora generalizzare è opportuno

ho bisogino di qualcosa di simile

e infatti @mpenet e’ un problema generale quello di convertire vecchi xsd->spec

anche l opposito, in caso mio

ah, allora speculate e’ estensibile credo (aggiungerci spec->xsd)

sto pensando a fare un lib typo goog/protobuf che usa spec

with optimisations that stuff like nippy just doesn't/can't do (varints, key cache, etc)

I thought protobuf was about RPC multi-language stuff, why do you need xsd there?

I don't, I need the opposite of what you're doing, going from spec to another format.

alright, spec to whatever another language is using to describe their endpoints I guess?

kinda yes

but it becomes hairy fast, parsing spec forms is not always trivial

@mpenet I’m working on spec->Dhall, and Dhall is a typed language with super efficient binary encoding

Specs are “types”, so I think the problem is manageable

But we’ll see

Also have a look at https://github.com/uswitch/speculate where the “parsing spec forms” is part of the lib

oh interesting

I know about speculate

it only outputs json spec and swagger currently, but it’s extensible

Oh wow this is cool

molto interessante speculate, grazie @reborg

:thumbsup: spero sia utile (non e’ prj mio, ma di un ex-collega)

spec-tools has also something similar (I think they call this a spec walker) but I am not a fan of that library

I ll (re)check both speculate and dhall. thanks

I’ll cut a release of dhall-clj later today, I’ll ping you then

domanda niubba, esiste un take-while che si "stoppa" quando la condizione è soddisfatta? :thistle:

si po fare con halt-when + transduce

uuuh quante funzioni che non conosco :smile:

mmmh Unable to resolve symbol: halt-when in this context

In che senso @andrea.imparato ?

(take-while #(< % 5) (range 10)) => (0 1 2 3 4)

dovrebbe essere in core no?

sarebe tipo take-until

esatto, take-while continua a "loopare" sulla lista

halt-when vienne con clj 1.9+

io voglio che si ferma

esempio se non ti dispiace?

una lista infinita di caratteri e voglio fermarmi quando trovo un punto

(defn generate-message[]
  (take-while #(clojure.string/includes? "." %) (filter #(re-find #"^[a-zA-Z]+" %)
          (take 1000 (markov-chains.core/generate (markov-chains.core/collate data 3))))))

mi sto divertendo con le markov chains :slightly_smiling_face:

(drop-while #(not= \. %) "vabene.questa?") => (\. \q \u \e \s \t \a \?)

mmmh la lista è tipo ("ciao" "mi" "piace" "clojure." "Ed" "altro")

io voglio tornare la lista fino alla parola con il punto

("ciao" "mi" "piace" "clojure.")

e togliere tutto quello che viene dopo

@andrea.imparato un for con :while non va bene?

il punto non dovrebbe stare insieme a nessuna parola @andrea.imparato imho

se migliori la tokenizzazione iniziale e' poi piu' semplice fare il resto

@nilrecurring "He really likes writing open source code, writing music, and writing pizza"

dalla tua bio su small fp conf :smile:

o pizza e' un linguaggio di programmazione nuovo :open_mouth:?

Effettivamente sarebbe un ottimo nome! Totalmente ingooglabile :smile:

beh ovviamente c'e' gia https://en.wikipedia.org/wiki/Pizza_(programming_language)

> Pizza also added function pointers and algebraic types with case classes and pattern matching. Pizza è molto meglio di Java a quanto pare

@andrea.imparato questo sembra funzionare (non elegantissimo… ma non mi viene altro…)

(reduce 
  #(let [r (conj %1 %2)] 
       (if (re-find #"\." %2) (reduced r) r)) [] coll)

grazie mille @reborg <3

o qualcosa di folle tipo (non testato) (reverse (takewhile #(not (.endsWith "." %)) (reverse s)))

(come non detto non puo' funzionare cosi)

cmq si se tokenizzi meglio diventa piu semplice

il . non dovrebbe stare con la parola