Scala solo linguaggio con estrattori sovraccaricati?

Question

In almeno alcuni dei linguaggi della famiglia ML, è possibile definire record in cui è possibile eseguire la corrispondenza del modello, ad es. http://learnyouahaskell.com/making-our-own-types-and-typeclasses - l'idea di base è quella di definire un tipo di record con campi denominati, un costruttore viene automaticamente creato con quei campi come parametri in modo da poter creare record di quel tipo e un estrattore viene creato automaticamente con quei campi come parametri in modo da poter creare corrisponde a record di quel tipo.

Scala fa un ulteriore passo avanti e consente ai campi memorizzati nel record, ai parametri del costruttore e ai parametri estrattore di essere disaccoppiati l'uno dall'altro, ad es. http://daily-scala.blogspot.com/2009/11/overloaded-unapply.html - in questo sta vivendo il suo obiettivo di supportare sia la programmazione orientata agli oggetti sia quella funzionale. (Naturalmente, i linguaggi orientati agli oggetti consentono di disaccoppiare i campi memorizzati ei parametri del costruttore, anche se normalmente non dispongono di estrattori.)

Esistono altri linguaggi che presentano la corrispondenza dei motivi e consentono tale disaccoppiamento?

È stato scritto qualcosa sui pro e contro di tale disaccoppiamento?

Answer 1

Ammetto che non ho il 100% dello sfondo richiesto per capire la tua domanda, ma posso dire che F # ha una funzionalità chiamata "Active Patterns" che sembra possa essere utilizzata per creare la stessa funzionalità del tuo daily-scala link dimostra.

E 'nelle vicinanze di quello che stai cercando?

Answer 2

No, F # fornisce anche questa funzionalità.

Esempi del secondo articolo possono essere implementate utilizzando Partial Active Patterns:

let (|String|_|) = function "s" -> Some "yay" | _ -> None 
let (|Int|_|) = function 1 -> Some "hmm" | _ -> None 

let (|StringList|_|) = function "x" -> Some [1; 2; 3] | _ -> None 
let (|IntList|_|) = function 1 -> Some ["one"; "two"] | _ -> None 

match 1 with 
| Int s -> printfn "%O" s 
| _ -> printfn "Unmatched" 

match "s" with 
| String s -> printfn "%O" s 
| _ -> printfn "Unmatched" 

match "x" with 
| StringList [x; y; z] -> printfn "%O" (x, y, z) 
| _ -> printfn "Unmatched" 

match 1 with 
| IntList [x; y] -> printfn "%O" (x, y) 
| _ -> printfn "Unmatched" 

Patterns attivo è una tecnica potente, è possibile anche scrivere in un modo recursive. La sua combinazione con il pattern matching fornisce un comodo toolkit per la destrutturazione dei dati. Tuttavia, la corrispondenza del modello è inesausta, pertanto è necessario utilizzare il carattere jolly (_) come ultimo modello.

Answer 3

Per riferimento, Don Syme (l'inventore di F #) ha scritto un articolo su 'Modelli attivi' s 'F #: Extensible Pattern Matching Via a Lightweight Language Extension – Syme, et al.

Answer 4

C'è una lunga storia di modelli di prima classe in linguaggi funzionali tipizzati.

In terra Haskell, viene utilizzata l'estensione -XViewPatterns per motivi programmatici.

I primi veri modelli di vista risalgono al 1987 la carta di Phil Wadler su views