Progettare il letterale della gamma perfetta

E il vincitore è

Ci scusiamo per aver scelto la mia soluzione, apprezzo molto tutti i commenti e i commenti e ti prego di criticare questa soluzione se trovi qualcosa di sbagliato con essa

Quindi ho deciso di andare con:

0..5           = 0,1,2,3,5
0..5..10       = 0,5,10
..3            = 0,1,3
!0..!5         = 1,2,3,4
3..            = 3 to infinity

segmented ranges
-
0..5,..5..20   = 0,1,2,3,4,5,10,15,20
0..3,10..5..20 = 0,1,2,3,10,15,20

Come puoi vedere inclusivo è il default su entrambi i sensi, è ciò che rende intuitivamente più sensato specialmente quando si usa lo stepping. Puoi usare ! per fare una fine esclusiva.

Lo svantaggio è che normalmente si desidera utilizzare l'esclusiva quando si lavora contro un array, ma di nuovo, la maggior parte delle volte si dovrebbe probabilmente usare qualcosa come per-ciascuno in questi casi. Se davvero hai davvero bisogno di lavorare contro l'indice, il parser potrebbe riconoscere quando hai dimenticato il marker di esclusione alla fine ed emettere un avviso

Sono andato usando ... su entrambi i lati della variabile step invece di usare la virgola o qualsiasi altra cosa poiché è quello che sembrava più pulito e spero sia il più leggibile.

Ho anche inserito alcune sintassi con le virgole per poter creare intervalli in cui parti diverse hanno passaggi diversi

Perché inventare ciò che esiste già in Matematica?

Notazione intervallata

Dovrebbe coprire il tuo punto "Unambiguity" così com'è già.

Il tuo unico problema sarebbe la definizione del passo. Forse qualcos'altro in matematica può essere d'aiuto?

Hai visto le gamme Haskell? La loro idea di passaggi è simile alla tua (nel mezzo) ma indicata con una differenza sintattica (da @ luqui's answer ):

[1,2..10] = [1,2,3,4,5,6,7,8,9,10]
[1,3..10] = [1,3,5,7,9]
[4,3..0]  = [4,3,2,1,0]
[0,5..]   = [0,5,10,15,20,25,30,35...  -- infinite
[1,1..]   = [1,1,1,1,1,1,1,1,1,1,1...  -- infinite

Trovo questa notazione molto intuitiva: inizi a enumerare e saltare il corpo per contrassegnare dove dovrebbe finire.

Non copre il caso di "esclusivo", ma francamente, preferisco essere chiaro riguardo al comportamento una volta (specificare quale limite è inclusivo e quale è esclusivo), e si aspetta che l'utente esegua le regolazioni a meno che la sintassi non sia < em> estremamente clear (e non confonde gli editor agnostici della lingua).

Dovresti leggere la comprensione degli elenchi nelle lingue che li offrono.

Python, ad esempio, copre i tuoi casi molto bene con la funzione range() e la comprensione delle liste per i casi troppo complessi da esprimere con range() .

Credo che la tua notazione sia lontana dall'essere ambigua. Intuitivamente, [0..5..20] non mi sembra un intervallo con larghezza del passo = 5. In alcuni casi d'angolo fallisce anche: per quanto riguarda l'espressione del set (0,2) - [0..2..2] o cosa dovrei mettere nel mezzo ?

Penso che la notazione a slice di Python sia un approccio solido: [start:end:step] (il passaggio è facoltativo).

Se hai davvero bisogno di supporto per intervalli esclusivi e inclusivi, utilizzerei la notazione degli intervalli standard (cioè utilizzando ( e [ ) a meno che ciò non introduca ambiguità sintattiche nella tua lingua.

Penso che quando imposti un terzo valore di incremento, è meglio aggiungerlo alla fine piuttosto che al centro, poiché si tratta di un valore facoltativo e sembra più intuitivo per i programmatori esperti che aggiungere un terzo argomento opzionale nel mezzo.

così invece di [1..5..20] potresti fare qualcosa come [1..20] [5] o [1..20.5]

• [1..5 [1,2,3,4
• ] 1..5] 2,3,4,5
• ] 1..5 [2,3,4

Perché non usare solo [1..4], [2..5], [2..4]? L'esclusione degli intervalli non offre molti vantaggi. Non è necessario scrivere MIN + 1 o MAX-1, sì, ma non lo vietano comunque. Troppa variazione, imho. Il mio linguaggio di scelta, scala, ha (da 1 a 3) e (1 fino a 3) [= (1 a 2)] ma mi ha appena confuso all'inizio. Ora uso sempre 'xey' e so, quindi, che l'opzione che non uso è quella esclusa, ma ovviamente non traggo vantaggio da un'opzione che non uso.

• [5..1] 5,4,3,2,1

è ovviamente (da 1 a MAX) (x = > y = (MAX + 1) - x) ma questo è molto più semplice e non facile da usare.

• [0..5..20] 0,5,10,15,20

è ovviamente (da 0 a 4) (x = > y = x * 5) non è tanto una caldaia. Discutibile.

Che dire di qualcosa di simile:

• [5..1] 5,4,3,2,1
• [1..5] [i, e] 1,2,3,4
• [5..1] [i, e] 5,4,3,2
• [1..5] [e, i] 2,3,4,5
• [1..5] [e, e] 2,3,4
• [0..20] di 5 0,5,10,15,20

Il i e e nella seconda coppia di parentesi quadre indica se l'inizio o la fine dell'intervallo è inclusivo o esclusivo (oppure potresti usare incl e excl se vuoi essere più chiaro). il by 5 indica l'intervallo di passo. Il primo e l'ultimo esempio sono comprensivi del primo e dell'ultimo valore, quindi ho omesso [i,i] , che a mio avviso sarebbe un comportamento predefinito assunto correttamente.

I valori predefiniti potrebbero essere [i,i] per lo specificatore inclusivo / esclusivo e by 1 per lo specificatore del passo.

Normalmente avrei suggerito la notazione standard che comprendeva ( e [ come menzionato da @Dan McGrath, ma sono d'accordo sul fatto che nel codice questo potrebbe sembrare confuso.

Non userei il modulo [1..5 ['per uno degli stessi motivi per evitare di mescolare parens e parentesi graffe: confonderà la maggior parte delle parentesi graffe degli editor esistenti. Forse usa un pennarello all'interno delle parentesi graffe, come '[1 .. | 5]'.

L'altra cosa da considerare è il comportamento dei metodi per ottenere i limiti. Ad esempio, 'begin' / 'end' vs. 'first' / 'last' vs. 'min' / 'max'. Hanno bisogno di essere sani per i limiti sia inclusivi che esclusivi, così come quelli con una dimensione di passo.

Ruby ha notazione e un intervallo oggetto che funziona. Essenzialmente assomiglia a questo:

1..5  # range 1,2,3,4,5

Con Ruby, la dimensione del passo non è una funzione dell'intervallo, ma piuttosto una funzione di iterazione nell'intervallo. Potremmo usare lo stesso intervallo sopra e iterarlo diversamente se vogliamo:

(1..5).step(3) { |x| puts x }
(1..5).step(2) { |x| puts x }

Quindi ecco alcune cose che potresti voler prendere in considerazione:

• L'aggiunta del supporto linguistico per endpoint inclusivi / esclusivi può essere problematica. Se tutti gli intervalli sono inclusi (scelta di Ruby), gli sviluppatori modificheranno di conseguenza gli endpoint dell'intervallo. Come rappresenti l'endpoint o l'esclusività in un modo che sia visivamente non ambiguo e non ambiguo con una semplice grammatica del parser?
• Stai utilizzando l'intervallo per più di una semplice iterazione? Esempi comuni includono confronti tra range, splicing, value in range selection. Se sì, come rappresenti queste possibilità? (Vedi il link alla classe Range per le idee su ciascuno di questi esempi.)

A proposito, gli intervalli sono piuttosto buoni se si consente loro di essere inclusi in un'istruzione switch come fa Ruby:

switch(myval)
    when 0..33 then puts "Low"
    when 34..66 then puts "Medium"
    when 67..100 then puts "High"
end

Non sto dicendo che l'oggetto della gamma di Ruby sia il fine e tutto, ma è un'implementazione funzionante del concetto di cui stai parlando. Gioca con esso per vedere cosa ti piace, non ti piace e farebbe diversamente.

Una soluzione che ritengo senz'altro stia utilizzando l'overloading dell'operatore per consentire ad es.

1+[0..3]*5

Non sarebbe necessariamente immediatamente trasparente per tutti, ma una volta che si fermano e pensano che spero la maggior parte dei programmatori lo capiscano, e le persone che usano regolarmente la lingua lo apprenderanno semplicemente come un idioma.

Per chiarire, il risultato sarebbe [1, 6, 11, 16] , sollevando la moltiplicazione e quindi l'aggiunta sull'intervallo. Non mi ero reso conto che potrebbe essere ambiguo per gli utenti Python; Penso agli intervalli come sottoinsiemi di ordini totali piuttosto che a elenchi. e ripetere un set non ha senso.