operators - periodistico - ¿Ya existe esta característica de lenguaje?

tipos de lenguaje

Question

Actualmente estoy desarrollando un nuevo lenguaje para la programación en un entorno continuo (lo comparo con la ingeniería eléctrica), y tengo algunas ideas sobre la construcción de un determinado lenguaje.

Déjame explicarte la característica por explicación y luego por definición:

x = a U b;

Donde x es una variable y a y b son otras variables (o valores estáticos). Esto funciona como una unión entre b ; Sin duplicados y sin orden específico.

with(x) {
    // regular ''with'' usage; using the global interpretation of "x"
    x = 5;
    // effectively will do:
    // x = a U b U 5;
    // a = 5;
    // b = 5;
    // Thus, when "a" or "b" changes, "x" is still equal to "5".
}
with(x = a) {
    // this code block is executed when the "x" variable
    // has the "a" variable assigned. All references in
    // this code-block to "x" are references to "a". So saying:
    x = 5;
    // would only change the variable "a". If the variable "a"
    // later on changes, x still equals to 5, in this fashion:
    // ''x = a U b U 5;''
    // ''[currentscope] = 5;''
    // thus, ''a = 5;''
}
with(x = b) {
    // same but with "b"
}
with(x != a) {
    // here the "x" variable refers to any variable
    // but "a"; thus saying
    x = 5;
    // is equal to the rewriting of
    // ''x = a U b U 5;''
    // ''b = 5;'' (since it was the scope of this block)
}
with(x = (a U b)) {
    // guaranteed that "x" is ''a U b''; interacting with "x"
    // will interact with both "a" and "b".
    x = 5;
    // makes both "a" and "b" equal to 5; also the "x" variable
    // is updated to contain:
    // ''x = a U b U 5;''
    // ''[currentscope] = 5;''
    // ''a U b = 5;''
    // and thus: ''a = 5; b = 5;''.
}
// etc.

En lo anterior, todos los bloques de código se ejecutan, pero el "alcance" cambia en cada bloque cómo se interpreta x . En el primer bloque, se garantiza que x es a: así, interactuar con x dentro de ese bloque interactuará en a . El segundo y el tercer bloque de código solo son iguales en esta situación (porque not a : entonces solo queda b ). El último bloque garantiza que x es al menos a o b .

Además; U no es el "operador o bitwise", pero lo he llamado el operador "y / o". Su definición es:

"U" = "and" U "or"

(En mi blog, http://cplang.wordpress.com/2009/12/19/binop-and-or/ , hay más información de fondo (matemática) sobre este operador. Se basa libremente en conjuntos. Usando una sintaxis diferente, Lo cambié en esta pregunta.)

Actualización: más ejemplos.

print = "Hello world!" U "How are you?"; // this will print
                                         // both values, but the
                                         // order doesn''t matter.
// ''userkey'' is a variable containing a key.
with(userkey = "a") {
    print = userkey; // will only print "a".
}
with(userkey = ("shift" U "a")) {
    // pressed both "shift" and the "a" key.
    print = userkey; // will "print" shift and "a", even
                     // if the user also pressed "ctrl":
                     // the interpretation of "userkey" is changed,
                     // such that it only contains the matched cases.
}
with((userkey = "shift") U (userkey = "a")) {
    // same as if-statement above this one, showing the distributivity.
}

x = 5 U 6 U 7;
y = x + x; // will be:
// y = (5 U 6 U 7) + (5 U 6 U 7)
//   = 10 U 11 U 12 U 13 U 14

somewantedkey = "ctrl" U "alt" U "space"
with(userkey = somewantedkey) {
    // must match all elements of "somewantedkey"
    // (distributed the Boolean equals operated)
    // thus only executed when all the defined keys are pressed
}
with(somewantedkey = userkey) {
    // matches only one of the provided "somewantedkey"
    // thus when only "space" is pressed, this block is executed.
}

Update2: más ejemplos y algunos más contexto.

with(x = (a U b)) {
    // this
}
// can be written as
with((x = a) U (x = b)) {
    // this: changing the variable like
    x = 5;
    // will be rewritten as:
    // a = 5 and b = 5
}

Alguna información de fondo: estoy creando un lenguaje que es "independiente del tiempo", como Java es "independiente de la plataforma". Todo lo que se indica en el idioma es "como es" y se ejecuta de forma activa y continua. Esto significa; el programador no sabe en qué orden (a menos que se indique explícitamente mediante el uso de construcciones) los elementos, ni cuándo se ejecutan las instrucciones. El idioma está completamente separado del concepto "tiempo", es decir, se ejecuta continuamente:

with(true) {
    a = 0; // only runs once (lazy execution)
}

with(a < 5) {
    a++;
} // this is a loop-structure;
  // how and when it''s executed isn''t known however.

with(a) {
    // everytime the "a" variable changes, this code-block is executed.
    with(true) {
        b = 3; // only 5 times (again lazy execution, but it''s a sub-with)
    }
    with(b < 2) { // dependent on "b"
        // runs only 3 times * 5 times = 15 times.
    }
    with(b > 1) { // dependent on "b"
        b = b - 1; // runs 4 times * 5 times = 20 times.
    }
}

Actualización 3:

Después de reflexionar sobre el tipo de esta característica de lenguaje; se parece mucho a la búsqueda de la plataforma de Netbeans, donde cada "con" -la declaración es un agente sincronizado, trabajando en su "filtro" específico de objetos. En lugar de basarse en el tipo, se basa en variables (básicamente lo mismo; solo una forma diferente de identificar objetos).

Les agradezco enormemente a todos ustedes por brindarme información muy perspicaz y enlaces / sugerencias sobre grandes temas que puedo investigar. Gracias.

No sé si esta construcción ya existe, así que esa es mi pregunta: ¿ya existe esta característica de lenguaje?

Answer 1

C # ciertamente no tiene las características que estás describiendo. De lo que estás hablando parece algo que recuerda al cálculo pi de Robin Milner; se trata de definir un lenguaje para describir procesos concurrentes. Si no lo ha hecho, podría considerar hacer una investigación al respecto.

Answer 2

Deberías haber inventado tus propios símbolos, incluso para el ejemplo.

Parece que está tratando de hacer referencias variables que cambian dinámicamente según lo requiera la definición del alcance. Esa es una técnica muy sutil y no conozco ningún idioma que lo haga. La mayoría de los idiomas requieren que hagas esto explícitamente, aunque puedo ver similitudes con los cierres, los generadores y el seguimiento.

¿Podría explicar el contexto que impulsa este método inusual? Tu enlace de blog no fue muy útil. Y el término ''programación continua'' tampoco está definido o explicado.

Actualizar:

Bien, mirando tu ejemplo editado, puedo señalar que Icon tiene algo similar. No es exactamente lo que crees que estás pidiendo, y no es común, pero parece cercano y está mucho mejor definido. Se llama evaluación dirigida por objetivos.

Muchos elementos del lenguaje proporcionan o le permiten construir un generador que puede ofrecer varias alternativas si se lo solicita. La principal diferencia entre su ejemplo e icono es que debe proporcionar un contexto para que el idioma siga intentando alternativas. La asignación no lo hace, pero una comparación lo hará. Una vez que un generador se queda sin valores que puede suministrar, falla . Esta es también la forma en que funciona la comparación ordinaria y la característica completa se integra perfectamente en el lenguaje más amplio. (A veces lo describo como una excepción en miniatura).

Python y Ruby tienen un mecanismo de yield que es muy similar e indudablemente influenciado por los generadores de Icon.

Answer 3

El "con" existe en as3:

private var _a:Number = 0.0;
public function get a():Number{
// Do stuff
    return _a;
}
public function set a(value:Number):void{
// Do stuff
    _a=value;
}

Answer 4

El lenguaje de creación de informes de IF tenía esta característica. Desde el DM :

if (alpha == 3 or 4) print "Scott";

Sin embargo, en realidad no se ha popularizado mucho más, ya que es un poco extraño analizarlo (tiene que asociar a cada operador or operador con un propietario particular == / != Comparador), y en los lenguajes de scripting modernos es fácil de reemplazar con algo como:

if alpha in (3, 4):
    print ''Scott'';

(Ejemplo de Python.)

Answer 5

Encuentro esto difícil de seguir, pero quieres decir eso:

x == a | b 

Será sintaxis azúcar equivalente a:

(x == a) || (x == b)

En la publicación del blog se da este ejemplo:

1 + (2|3)

Entonces, el tipo de esa expresión es un par de enteros con los valores 3 y 4, cada uno representando uno de los valores posibles. Así que también podemos decir:

4 == (1 + (2|3)
3 == (1 + (2|3)

y ambos de esos evaluarían a verdadero. Por lo tanto, el operador == puede comparar un valor con un tipo de vector de valores y será true si alguno de los valores en el vector es igual al primer valor.

Esto podría implementarse utilizando la sobrecarga de operadores en algunos idiomas (aunque tendría que "levantar" explícitamente los valores simples en un tipo de envoltura antes de poder operar con ellos).

¿No es efectivamente igual a la unión de dos conjuntos, y con == interpretado como "es un miembro de"? Y a los operadores les gusta + ser levantados para que se apliquen a todos los miembros del conjunto.

Y si lo hiciera (1 | 2) + (4 | 8) obtendría el equivalente de (5 | 9 | 6 | 10), porque esos son los cuatro resultados posibles.

Bien, de los ejemplos adicionales que agregó, veo que == en realidad requiere que los lados izquierdo y derecho sean el mismo conjunto, en lugar de simplemente superponerse. Pero todavía tengo la impresión de que tu | Es simplemente la unión de dos conjuntos. Lo que esto implica (o significa) dependerá de lo que haga con todas las demás funciones de su idioma para lidiar con los conjuntos.

Con respecto a su declaración:

El lenguaje está completamente separado del "tiempo" -concepto

¿Has mirado mucho en lenguajes puramente funcionales como Haskell? Los programas son una serie de definiciones sin un orden de ejecución conocido, solo puede escribir funciones puras sin efectos secundarios y, por lo tanto, el intérprete puede ordenar la ejecución como quiera, siempre que los valores estén disponibles cuando realmente sean necesarios.

Actualizar:

Agregaste esto a tu pregunta:

if(x == a | b) {
    // this 
}
// can be written as
if((x == a) | (x == b)) {
    // this
}
// which can be written as
if(x == a) {
    // this
}
if(x == b) {
    // with this
}

¡Me pregunto cómo crees que será iluminador!

La cosa es que las dos primeras versiones tienen un bloque de código debajo del if. Entonces, si la tercera versión expandida tiene dos bloques, deben ser el mismo bloque . En otras palabras, esta es solo otra forma de escribir:

if (x == a || x == b) {
    // this
}

Donde || Es el tradicional booleano OR. Cuál es exactamente la pregunta que hice primero.

Bien, una vez más ... Ahora has cambiado la sintaxis para indicar que estás haciendo uniones e intersecciones. Pero entonces:

if(userkey I ("shift" U "a")) {
    // pressed both "shift" and the "a" key.

Así I significa tomar la intersección de los dos conjuntos ... pero if ejecuta el bloque de código, ¿en qué circunstancias? Si la intersección no está vacía? O I de hecho, I preguntando "son todos los miembros del conjunto de los miembros correctos del conjunto de la izquierda" Y hay indicios de que la userkey se reemplaza en el alcance del bloque por otro valor que en realidad es el conjunto de la derecha .

Me voy a la cama.

Answer 6

Honestamente, encuentro su explicación y ejemplos difíciles de seguir ( actualice: su blog es mucho mejor y al leer el Formulario de pedidos allí, estoy aún más convencido de que está apuntando a una forma de programación de flujo de datos ).

Sin embargo, su descripción final:

Todo lo que se indica en el idioma es "como es" y se ejecuta de forma activa y continua. Esto significa; el programador no sabe en qué orden (a menos que se indique explícitamente mediante el uso de construcciones) los elementos, ni cuándo se ejecutan las instrucciones. El lenguaje está completamente separado del concepto "tiempo", es decir, se ejecuta continuamente: decir que "a" es "b" y "b" es "a" es una estructura de bucle simple, por ejemplo.

.. me induce a pensar que el término general que está buscando es programación de flujo de datos (incluso si los bucles no están permitidos en las instancias más simples de la programación de flujo de datos). Citando de Wikipedia:

Dataflow es una arquitectura de software basada en la idea de que cambiar el valor de una variable debería forzar automáticamente el recálculo de los valores de las variables que dependen de su valor.

La programación reactiva y la programación reactiva funcional son, según yo las entiendo , variaciones sobre el mismo tema.

La evaluación dirigida al objetivo del icono tiene un alcance más restringido (consulte esto Una breve introducción al icono : el retroceso que implica el mecanismo de evaluación dirigido al objetivo se limita a la expresión en la que se produce ).

Vea también esta pregunta en : Dataflow Programming Languages .

Actualización: Pindatjuh pregunta en los comentarios " ¿Puede también comentar si este lenguaje es una nueva variación sobre el tema del flujo de datos? ". Creo que sí, pero la pregunta es realmente acerca de las definiciones y también acerca del consenso. En una encuesta reciente sobre lenguajes de flujo de datos, Avances en los lenguajes de programación de flujo de datos (publicado en ACM Computing Surveys, Volumen 36, Número 1, marzo de 2004 ), los autores escribieron (página 10):

La mejor lista de características que constituyen un lenguaje de flujo de datos fue presentada por Ackerman [1982] y reiterada por Whiting y Pascoe [1994] y Wail y Abramson [1995]. Esta lista incluye lo siguiente:

1. libre de efectos secundarios,
2. localidad de efecto,
3. dependencias de datos equivalentes a la programación,
4. asignación única de variables,
5. una notación inusual para iteraciones debido a las características 1 y 4,
6. Falta de sensibilidad al historial en los procedimientos.

No he leído todo tu blog, pero lo he leído ligeramente, así que estás más calificado que yo para juzgar tu lenguaje de programación (que es un objetivo en movimiento de todos modos).

Actualización: inconscientemente me perdí la palabra "nuevo" en su pregunta " ... este lenguaje es una nueva variante de ... ". Es una tarea difícil: uno debe considerar todos los lenguajes de flujo de datos inventados hasta ahora y examinar cuidadosamente su semántica en detalle para detectar una novedad en su enfoque. Seguramente no tengo los conocimientos necesarios en este momento.

Answer 7

Pareces estar hurgando en torno a varias ideas a la vez:

• Una sintaxis de lista donde haces algo como 5 | 6 | 7 5 | 6 | 7
• usando el producto externo donde has estado escribiendo ::list:: + ::list::
• definir cuidadosamente el significado de los operadores de igualdad, desigualdad, asignación, etc. cuando uno o ambos argumentos es una lista. Es decir que ::scalor:: == ::list:: implementa "es un elemento de", y así sucesivamente

No tengo conocimiento de una sola función sintáctica que combine esas ideas, pero no tengo mucha experiencia ...

Answer 8

Su función de idioma se parece a junctions en Perl 6.

En Perl 5, está el módulo Quantum::Superpositions .

Answer 9

Te aconsejo que no agregues esa característica del lenguaje. Sería muy poco claro para el programador que el significado de x cambia si realiza una "prueba" como:

if( x != a ) { ... }

Answer 10

Tus ejemplos y tus cálculos matemáticos podrían ser útiles, pero en al menos uno de los ejemplos de tu blog, tu uso de | se asemeja mucho al uso del mismo operador (creo que se llama "alternancia") en el lenguaje de programación Icon .

Si vas a comprometer el diseño del lenguaje en esta área, definitivamente debes leer sobre

• Modelo de ícono de evaluación dirigido a objetivos.
• Programación reactiva funcional y la forma en que modela el tiempo continuo.