programming languages tiobe Linguaggio veramente dichiarativo?



tiobe index programming languages 2018 (16)

In F #, un po 'verbosamente:

let x = ref 10
let y = ref 20

let z () = !x + !y

z();;
y <- 40
z();;

Qualcuno sa di una lingua veramente dichiarativa? Il comportamento che sto cercando è quello che fa Excel, dove posso definire variabili e formule, e cambiare i risultati della formula quando l'input cambia (senza aver impostato di nuovo la risposta)

Il comportamento che sto cercando è meglio mostrato con questo pseudo codice:

X = 10     // define and assign two variables
Y = 20;

Z = X + Y  // declare a formula that uses these two variables

X = 50     // change one of the input variables

?Z         // asking for Z should now give 70 (50 + 20)

Ho provato questo in molti linguaggi come F #, python, matlab ecc, ma ogni volta che provo questo, ne escono 30 anziché 70. Che è corretto da un punto di vista imperativo, ma sto cercando un più comportamento declerativo se sai cosa intendo.

E questo è solo un calcolo molto semplice. Quando le cose diventano più difficili, deve gestire automaticamente cose come ricorsione e memoizzazione.

Il codice qui sotto funzionerebbe ovviamente in C # ma è solo un gran numero di codice per il lavoro, sto cercando qualcosa di più al punto senza tutto quel 'rumore tecnico'

class BlaBla{
    public int X {get;set;}  // this used to be even worse before 3.0
    public int Y {get;set;}
    public int Z {get{return X + Y;}}
}

static void main(){
   BlaBla bla = new BlaBla();
   bla.X = 10;
   bla.Y = 20;
   // can't define anything here
   bla.X = 50; // bit pointless here but I'll do it anyway. 
   Console.Writeline(bla.Z);// 70, hurray!
}

Questo sembra un codice simile, parentesi graffe e punto e virgola che non aggiungono nulla.

Esiste una lingua / applicazione (oltre a Exel) che fa questo? Forse non lo faccio nel modo giusto nelle langauges menzionate, o ho completamente perso un'app che fa proprio questo.

Ho prototipato un linguaggio / un'applicazione che fa questo (insieme ad altre cose) e sto pensando di produrlo. Non riesco a credere che non sia ancora lì. Non voglio perdere tempo.


Answer #1

Hai visto Resolver One ? È come Excel con un vero linguaggio di programmazione.


Answer #2

Puoi imitarlo in Ruby:

x = 10
y = 20
z = lambda { x + y }
z.call    # => 30
z = 50
z.call    # => 70

Non proprio come quello che vuoi, ma piuttosto vicino.


Answer #3

non sono sicuro di quanto bene metapost ( 1 ) possa funzionare per la tua applicazione, ma è dichiarativo.


Answer #4

Questo codice F # dovrebbe fare il trucco. È possibile utilizzare la valutazione lazy (oggetto System.Lazy) per garantire che l'espressione venga valutata quando è effettivamente necessaria, non prima.

let mutable x = 10;
let y = 20;

let z = lazy (x + y);
x <- 30;

printf "%d" z.Value

Answer #5

JavaFX lo farà per te se usi bind invece di = per Z


Answer #6

Puoi farlo in Tcl, un po '. In tcl è possibile impostare una traccia su una variabile in modo tale che ogni volta che si accede a una procedura può essere invocato. Quella procedura può ricalcolare il valore al volo.

Di seguito è riportato un esempio funzionante che fa più o meno quello che chiedi:

proc main {} {
    set x 10
    set y 20
    define z {$x + $y}

    puts "z (x=$x): $z"
    set x 50
    puts "z (x=$x): $z"
}


proc define {name formula} {
    global cache
    set cache($name) $formula
    uplevel trace add variable $name read compute
}

proc compute {name _ op} {
    global cache
    upvar $name var
    if {[info exists cache($name)]} {
        set expr $cache($name)
    } else {
        set expr $var
    }
    set var [uplevel expr $expr]
}

main

Answer #7

C'è una libreria Lisp con questo tipo di comportamento:

cells


Answer #8

Qualsiasi sistema di programmazione dei vincoli lo farà per te. Esempi di sistemi CP con una lingua associata sono ECLiPSe , pacchetto SICSTUS Prolog / CP, Comet, MiniZinc, ...


Answer #9

In Mathematica puoi fare questo:

x = 10;     (* # assign 30 to the variable x *)
y = 20;     (* # assign 20 to the variable y *)
z := x + y; (* # assign the expression x+y to the variable z *)
Print[z];
(* # prints 30 *)
x = 50;
Print[z];
(* # prints 70 *)

L'operatore := (SetDelayed) è diverso da = (Set). Il primo lega un'espressione non valutata a una variabile, quest'ultima lega un'espressione valutata .


Answer #10

Il desiderio di avere due definizioni di X è intrinsecamente imperativo . In un linguaggio veramente dichiarativo hai una singola definizione di una variabile in un singolo ambito. Il comportamento che vuoi da Excel corrisponde alla modifica del programma.


Answer #11

Due cose che puoi guardare sono la libreria di cells libere e il linguaggio di modellazione dinamica Modelica , che hanno entrambe capacità di relazione / equazione.


Answer #12

Non è quello che stai cercando, ma le lingue di descrizione dell'hardware sono, per definizione, "dichiarative".


Answer #13

Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio

x = 10
y = 20
z = function () return x + y; fine
x = 50
= z ()
70



Answer #15

Ecco l'esempio di Daniel in Python, dal momento che ho notato che hai detto di averlo provato in Python.

x = 10
y = 10

z = lambda: x + y

# Output: 20
print z()

x = 20

# Output: 30
print z()