Mathematica è un linguaggio non tipizzato?

Question

A differenza della maggior parte dei linguaggi di programmazione, ogni valore in Mathematica è un'espressione. L'applicazione di qualsiasi operazione a qualsiasi espressione produce sempre un'altra espressione. Di conseguenza, Mathematica ha effettivamente un solo tipo. Mathematica non esegue controlli di tipo statico e, probabilmente, non controlla nemmeno i tipi in modo dinamico (in fase di esecuzione).

Ad esempio, aggiungendo l'espressione intera 1 all'espressione stringa "foo" nei risultati Mathematica nella (assurdo) espressione 1 + "foo" ma nessun errore. In altri casi, Mathematica fornisce feedback sugli input non sensoriali, ma i controlli che generano questo feedback devono essere eseguiti esplicitamente dal programmatore.

Quindi, è corretto descrivere Mathematica come un linguaggio non tipizzato rispetto a un linguaggio tipizzato staticamente o dinamicamente?

Answer 1

La risposta breve: Untyped o typeless. Ecco come Wolfram Research descrive il prodotto da sé. See here.

Risposta lunga: Jon, penso che la tua domanda dipenda davvero da cosa intendi per "non tipizzato". Per fare appello alla risorsa definitiva che è Wikipedia "Al contrario, un linguaggio non tipizzato, come la maggior parte dei linguaggi di assemblaggio, consente di eseguire qualsiasi operazione su qualsiasi dato, che sono generalmente considerati come sequenze di bit di varie lunghezze."

Leggendo le risposte precedenti, sembra che il cuore del dibattito sia quello che dovrebbe essere un controllore di tipi quando incontra un errore. La solita risposta è FERMARE la valutazione e segnalare un qualche tipo di errore. Da alcune precedenti domande (1) e (2) su Stackoverflow, possiamo vedere che non esiste un modo elegante per eseguire questo built-in in Mathematica. (Vorrei aggiungere l'avvertenza che con più enfasi sulla compilazione in C nella versione 8 che è possibile scrivere il tipo di codice controllato, ma non sono sicuro se questo dovrebbe essere contato come parte della lingua principale.)

Answer 2

Mathematica ha alcuni tipi ed è dinamico. Hai i tipi String, Integer, Real, Complex, List e Symbol. È possibile creare funzioni che operano su un solo tipo facendo qualcosa di simile

f[x_Integer]:=x+1

per creare una funzione che opera solo su interi.

Matematica è fortemente basata su schemi e sostituzioni; i tipi mi sembrano sempre un altro modo per aiutarti a sviluppare schemi. Nel caso di , non esiste un modello per valutare un numero aggiunto a una stringa, quindi il risultato è solo l'espressione stessa. Nel caso di 1 + 2, esiste un modello per aggiungere i numeri e viene valutato. I modelli e le regole di sostituzione di Mathematica possono essere molto più complessi e, se sei interessato, è meglio leggere un libro.

Answer 3

Più che dal lato pratico delle cose, credo che si possa dire che Mathematica sia più indipendente dal tipo che non tipizzato.

Inoltre, è possibile costruire facilmente un sub-linguaggio a tipizzazione utilizzando le cose come (esempio molto semplice segue):

Unprotect[Set]; 

Set[a, x_] := If[Element[x, Integers], x, 0, 0]; 

e quindi provare:

a = 1; (*runs ok*) 

e

a = "caca" (*assigns zero to a*) 

Modifica

Inoltre, è possibile costruire tipi definiti dall'utente come modelli con nome e utilizzarli nella ridefinizione di Impostare in alto, anziché in numeri interi.
La composizione del tipo dovrebbe funzionare allo stesso modo.

Answer 4

Se consideriamo le frasi "staticamente digitato" e "digitato dinamicamente" come in gergo riferito a quando un linguaggio verifica la validità delle operazioni rispetto ai tipi, penso che sia corretto caratterizzare Mathematica usando il gergo "non tipizzato" - nel senso che "mai" controlla se un'operazione è valida per un tipo.

Mi piace l'uso del termine "tipo-agnostico" da parte di Belisario. Dico questo perché mentre quasi tutti i tipi di controllo nella lingua sono idiomatici (ad es.implementato dal programmatore, non dalla lingua), così è il concetto di applicare un operatore agli operandi digitati!

Considerare l'esempio "senza senso" di 1 + "foo". Penso che sia giusto dire che una frazione significativa (che si avvicina all'unità) di tutti gli utenti di Mathematica viaggia su casi come questo, poiché stanno imparando la lingua per la prima volta. Il problema è particolarmente evidente quando si scrive codice in, per esempio, lo stile di C. C'è molta discussione nei circoli di Mathematica su come gestire situazioni come queste.

D'altra parte, questa debolezza è anche il più grande punto di forza di Mathematica. Mathematica è ottimizzato per la creazione di nuove notazioni. Molte, molte notazioni hanno il concetto di + che si comporta in modo molto simile all'aggiunta nell'aritmetica elementare. Quando si creava tale notazione, sarebbe molto scomodo se Mathematica intervenisse e si lamentò che gli operandi a + non erano numeri. In un'applicazione di Mathematica di livello più elevato, l'esempio "insensato" non è solo "sensoriale", ma in realtà cruciale.

Quindi, con questo in mente, la questione del tipo è spesso discutibile. Quindi, mi piace la caratterizzazione "type-agnostic" Belisarius. lui Upvote, ho fatto;)

Modifica

Cercherò di chiarire quello che avevo in mente quando la distinzione tra "senza tipo" e "Tipo-agnostic".

Leggendo le varie risposte e commenti, ho cercato di capire quale fosse la differenza tra Mathematica e LISP. Quest'ultimo è generalmente considerato un esempio di "tipizzazione dinamica", sebbene il valutatore LISP di base sia molto simile a Mathematica con quasi nessun tipo di controllo. Gli errori di tipo che vediamo nei programmi LISP sono per lo più emessi da controlli codificati in funzioni (generalmente incorporate). +, ad esempio, accetta solo argomenti numerici anche se il valutatore stesso non potrebbe interessarsi di meno in un modo o nell'altro. Detto questo, il "sentire" della programmazione in LISP differisce notevolmente dal "sentire" di Mathematica (almeno per me). L'esempio 1 + "foo" cattura davvero questa differenza.

Mentre sono ampiamente d'accordo con "non tipizzato" come la caratterizzazione di Mathematica, ho comunque sentito che mancava qualcosa. Assembler sembra non tipico per me, così come i primi FORTRAN e pre-ANSI C. In quei casi, il modello di bit degli argomenti era tutto ciò che contava e i programmi continuavano in modo blissamente se passassi un argomento di stringa in cui era necessario un numero intero. Mathematica certamente condivide questo comportamento non tipizzato. Ma c'è una differenza: nell'assembler e FORTRAN e C, è estremamente raro che questa mancanza di controllo dei tipi porti a un buon risultato. Come ho detto sopra, in Mathematica è possibile, a volte anche comune, affidarsi a questo tipo di comportamento.

Inserire "tipo-agnostico". Mi è piaciuto il suo atteggiamento non impegnativo, suonando meno drastico di "non tipizzato". Ho sentito che rifletteva la natura essenzialmente non tipizzata di Mathematica, ma ha lasciato un po 'di spazio per quelle caratteristiche linguistiche che supportano prontamente il controllo dei tipi idiomatico in LISP, stile dinamico (cioè l'idioma "testa" e funzionalità di supporto).

Quindi, in breve, sento che Mathematica si aggira tra l'essere completamente senza tipizzazione e la digitazione dinamica. "Tipo-agnostico" ha catturato questo sentimento per me. YMMV :)

Confesso prontamente che nessuno è in grado di ricostruire qualsiasi cosa abbia scritto in questa risposta semplicemente dall'ispezione delle frasi "non tipizzato" e "tipo agnostico". Ancora una volta sottolineo che penso che "non tipizzato" sia una buona caratterizzazione di Mathematica, ma mi piace anche il fatto che "tipo agnostico" elogia molte delle domande che vengono affrontate dalle varie risposte a questa domanda.

Answer 5

Invece di "tipo", cosa Mathematica ha è il concetto di "testa", dove ogni Mathematica espressione possiede uno. Questo è in linea con il loro "everything is an expression" paradigm.

Si può scrutare la struttura di un Mathematica espressione attraverso le funzioni FullForm[] e Head[]. Per esempio, i rendimenti Head[3]Integer, Head[2/3] rendimenti Rational, Head[I] resi Complex, Head[.3] resi Real, Head[a] restituisce Symbol (supponendo che non si erano ancora assegnato nulla-a), Head["a"] rendimenti String, Head[{2}] restituisce List ... sono sicuro hai già un'idea.

La bellezza di questo è che si possono scrivere funzioni tali da poter accettare solo argomenti con teste specifiche. Per esempio:

f[x_Real] := x^2 

f[3] 
f[3] 

f[3.] 
9. 

Questo discussion sui modelli dovrebbe darvi idee su come impostare le funzioni in modo tale che essi funzionano solo su oggetti con testa o gruppi di testine specifici.