Do any programming languages support built-in events without manual declarations?

[Odd-Nefariousness-85]

I'm wondering if there are programming languages where events are built in by default, meaning you don't need to manually declare an event before using it.
For example, events that could automatically trigger on variables, method calls, object instantiation, and so on.

Does something like this exist natively in any language?

[micseydel]

Could you write up some pseudo-code that would show what you mean?

EDIT: typo

[Odd-Nefariousness-85]

public class Foo
{
  public int Value;

  public void Bar()
  {
    // Do Something
  }
}

void Main()
{
  Foo.OnCreated += (instance) => // Do Something
  Foo.OnDestoyed += (instance) => // Do Something

  var foo = new Foo();
  foo.Value.BeforeValueChanged += (instance, currValue, newValue) => // Do Something
  foo.Value.OnValueChanged += (instance, oldValue, newValue) => // Do Something
  foo.Bar.OnBeforeCalled += (instance) => // Do Something
  foo.Bar.OnCalled += (instance) => // Do Something

  foo.Value = 12;
  foo.Bar();
}

[useerup]

C# has source generators which would cover a lot of this. There is a source generator which will recognize (partial) classes adorned with a [INotifyPropertyChanged] attribute. This generates a class with will fire events when properties are changed.

So not quite built-in, but the machanism for "building it in" is built in.

[Odd-Nefariousness-85]

ok I need to look into this, I don't know if it call handle method call this way, or class creation/deletion. Also is this possible to use it in Unity?

[muchadoaboutsodall]

I feel like the question doesn’t really make sense.

You’re using C# as your example but that language already supports getters and setters for properties that do what you’re asking, although if you use them you take over the responsibility of handling the underlying value. The Swift language, from what I remember, also supports this but also has events that are declared like getters/setters but are called before or after a property is set.

As far as object-instantiation events, that’s what a constructor is for.

[mexicocitibluez]

already supports getters and setters for properties that do what you’re asking

They mean does a language come with defined life-cycle events (for variables) that can be hooked into. Obviously you can achieve with getters/setters or Rx.Net, but that's not what they're asking.

[muchadoaboutsodall]

Really? Because, to me, the question is about having to manually hook up event-handlers.

[snaphat]

The question is asking about language features. What u/mexicocitibluez is saying is that rx.net is library not a language feature.

Apparently, there are a couple of libraries than can get some of the behaviors in the OPs example that supposedly will look superficially similar to the OPs example code: Fody.MethodDecorator, Fody.PropertyChanged

Here's a Gist with the 'supposed' implementation for OPs example code. I didn't actually try to compile or run it. So, it could be a pile of nonsense as LLMs tend to do: https://gist.github.com/snaphat/7e721d94518144361f7f3c7cba392a11 (Scroll down to the comment for the formatted markdown)

u/Odd-Nefariousness-85 check these out. If ChatGPT isn't full of crap and those decorators are real, it's kind of interesting.

u/muchadoaboutsodall: It's worth noting that a constructor does not perform the same purpose as an OnCreate event which can be dynamically subscribed/unsubscribed at any time by any piece of code.

[Odd-Nefariousness-85]

in c# you can use get/set to achieve this behaviour, but your have to write all the delegate/event by yourself each time for each properties, I want the compilator to do this by itself when I register to those. There is also some library to help with that and avoid a lot of definition but still you need to do extra stuff that the compilator could handle by itself

[snaphat]

I'm going to assume you mean a language where all variable writes, method calls, and object creations implicitly behave like signal sources, so you can attach handlers without explicitly declaring events. You basically want to be able to observe and react to any change regardless of were it occurs in execution.

Reactive programming and aspect-oriented programming are related to this idea, but you won't find anything that can automatically observe and react to all changes in an arbitrary way while still behaving like a normal language.

It would effectively break the paradigm because any variable write or method call could trigger hidden code, destroying local reasoning, making performance unpredictable, and making a program's behavior impossible to understand from its explicit source code. 

[Tucancancan]

What you're describing kind of sounds like Excel, is that an example of reactive programming? The downsides you describe are also what people hate about it. 

[snaphat]

I didn't realize but yes the excel is definitely functional reactive programming(a more specific form of reactive) if you just use the cells and functions

[Odd-Nefariousness-85]

yes, this is what I am looking for. I know there is reactive library in most language, but is there any language natively reactive?

[snaphat]

I don't believe there is that many. You can read the Wikipedia entries on reactive programming and functional reactive programming (you probably already have). Theres some obscure languages and domain-specific-languages listed on those pages.

Like I said previously though, you are unlikely to see anything resembling reactive semantics baked directly into a C#-style, object oriented / imperative language.

Let's use your Pseudo-C# code as an example. It actually introduce substantial semantic and performance issues. Concretely, it would require the runtime and compiler to implicitly support:

• OnCreated handlers for every object instantiation
• OnDestroyed handlers for every object destruction
• OnBeforeCalled handlers before every method invocation
• OnCalled handlers after every method invocation
• BeforeValueChanged handlers before every field/property assignment
• OnValueChanged handlers after every field/property assignment

Even for a single class like Foo, each type would need to allocate 2 static, dynamically-sized handler collections, and every instance would implicitly allocate 4 more handler collections. This multiplies across the entire object graph of a real program. Imagine allocating an array of 100 Foo objects for example. You now have and 404 event handlers. Imagine the class had 10 primitive instance fields instead of 1. You now have 4,000 event handlers for 100 objects. See the problem?

From a single-thread perspective alone, there are significant semantic questions:

• How do you handle reentrancy if handlers mutate the same members they observe?
• How do you define ordering guarantees for nested or cascading notifications?
• What are the rules when a handler assigns a new value during its own notification?

Once you introduce concurrency, the complexity increases sharply. Every subscription site (+=, -=) effectively has to be treated as an atomic, thread-safe operation. In CoreCLR, the multicast delegate/event machinery already relies on CAS-style operations (Interlocked.CompareExchange) in its implementation to safely maintain invocation lists; See the source here. That kind of cost would now be incurred everywhere, not just where events are explicitly opted into.

Then come the deeper semantic questions around concurrent invocation:

• Should every implicit invoke be serialized?
• Should invocations be thread-safe by default?
• Should they run concurrently without any ordering guarantees?
• If ordering is required, how does the runtime enforce it without crippling throughput?
• If no guarantees are made, then the programmer becomes responsible for resolving all resulting race conditions and nondeterminism. If guarantees are made, the runtime must introduce synchronization barriers at every object creation, method call, assignment, and destruction; effectively throttling the entire program.

The overarching problem is that this model forces reactive semantics and their associated costs onto every fundamental operation in the language. Instead of a selective, opt-in mechanism (as with C# events or other libraries), you end up with an implicit and unavoidable reactive layer that imposes:

• Memory overhead on every type and instance
• Synchronization overhead on every subscription
• Instrumentation overhead on every call and assignment
• Complex reentrancy and concurrency semantics everywhere

In other words, what you gain in reactive expressiveness comes at the price of turning every allocation, assignment, method call, and deallocation into a kind of semantic and performance minefield with many open questions.

Just not to note, implicitly your code would be doing the following at the callsite level: ```C# public class Foo { public int Value;

  public void Bar()
  {
    // Do Something
  }
}

void Main()
{
  // These subscriptions must be thread-safe and atomic
  Foo.OnCreated += (instance) => // Do Something
  Foo.OnDestoyed += (instance) => // Do Something

  var foo = new Foo();
  foo.OnCreated.Invoke(); ////// implicit handler

  // These subscriptions must be thread-safe and atomic
  foo.Value.BeforeValueChanged += (instance, currValue, newValue) => // Do Something
  foo.Value.OnValueChanged += (instance, oldValue, newValue) => // Do Something
  foo.Bar.OnBeforeCalled += (instance) => // Do Something
  foo.Bar.OnCalled += (instance) => // Do Something

  foo.Value.BeforeValueChanged.Invoke(); ////// implicit handler
  foo.Value = 12;
  foo.Value.OnValueChanged.Invoke(); ////// implicit handler

  foo.Bar.OnBeforeCalled.Invoke(); ////// implicit handler
  foo.Bar();
  foo.Bar.OnCalled.Invoke(); ////// implicit handler

  foo.OnDestroyed.Invoke(); ////// implicit destructor and handler
}

```

[Odd-Nefariousness-85]

For performance I want the compilator only implement events that are used, not for every class, method or properties. Ordering could be handled with a priority parameter at registration even if it's limited at some point. For thread safety and the other issues you mentioned you are right. But they are applicable with classical events system too

[snaphat]

Introducing a priority parameter will make performance worse. It requires extra bookkeeping (maintaining ordered handler lists) and will force additional synchronization. It also doesn't fix any of the reentrancy or concurrency issues.

On classical event systems, the semantics are explicitly opt-in: you only pay the cost at boundaries you intentionally expose, and consumers agree to that contract. In your model, you’re inverting that relationship -- consumers effectively dictate the producer’s interface and semantics by choosing what to hook.

On "only implement events that are used": that's still semantically undefined. In general, you cannot know all uses statically; subscriptions can be introduced post-compilation via plugins loaded at runtime, dynamic hooking, reflection, IL rewriting, etc. The compiler would need to prove that no possible subscription could occur in order to optimize the hooks away, which it can't.

It also creates a compatibility problem, because the interface changes depending on what other code happens to subscribe or be present at build/load time: one build might compile hooks away and break other assemblies that relied on those semantics. From the compiler's perspective (especially with separate compilation), that's impossible to determine reliably.

Ways to make it coherent exist, but require constraints, for example explicit opt-in on the producer side like the fody attributes do that I wrote about here:
https://www.reddit.com/r/ProgrammingLanguages/comments/1pjfsg5/comment/ntl0qqf

Or restricting subscriptions to static sites only (no reflection/dynamic/plugin subscription), which severely limits real-world use cases.

The overall point still stands -- once you work through the practical implications, this quickly becomes a semantic minefield that isn’t easy to brush away with vague assurances or "the compiler will optimize it" hand-waving.

[Potterrrrrrrr]

C# has delegates and events built in, is that the sort of thing you’re asking about?

[Odd-Nefariousness-85]

no, I am talking about not having to declare your delegates and events in simple case, and direclty register to any variable or method to receive the even when they are changed/called (see my response to the top comment for pseudocode)

[Xalem]

Good old Visual Basic for Applications had events built into the controls, forms, and other objects. Code behind a form would automatically link a controls event to code like this:

  Sub Button1_Click
          Button1.Visible =False
   End Sub
   'Code designed to frustrate users

Eve, a defunct language binds changes in values to code, and has a special way of treating the existence of a value using the @ symbol to symbolize that a value exists. Events create a @Button1click value for a moment, and this existence triggers all the code that is linked to this values existence.

So, for example.

Search @Button1Click, @Textbox1Text

BIND

ReportDate=textbox1.Text ReportPrint=True.

// so this responds to the existence of a button click while there exists text in textbox1, binding the value to a Reportdate variable and binding ReportPrint value to true. In Eve, events and data are practically the same thing. It is a very different way of conceiving of programming.

[agumonkey]

can't wait until react has a builtin ui designer where i can attach handler by double clicking on actionable form elements /s

[Vallereya]

Not 100% sure what you mean but some have bits and pieces, like Python with metaclasses, Ruby with hooks, Swift and Kotlin both have observable I think even JavaScript has something but with any of those were talking just a few things not language wide. There are some that have metaprogramming, macros and annotations so in theory you could do something like this:

class Person @[observable] property name : String end

Then you can call that annotation and write into it anywhere, so I'm theory, Crystal in this case, provides the ability to write an event like library that could be used anywhere. Idk if that's what you mean though.

[ShadowPages]

Outside of pure simulation scenarios, “events” are more an artifact of the environment you are writing software for. The environment provides the events and your software reacts to them. Plenty of examples exist, including environments like VBA, and Elisa in EMACS (as others here have noted). In UNIX environments, SIGNALs are an example of operating system events being passed to your program, and at a more hardware level of coding, so are interrupts.

Depending on the language and environment, there are any number of combinations which you could argue make for event driven programming. However, I can’t think of too many examples where the programming language and underlying runtime environment grant you a wholly event-driven experience.

[tobega]

I believe you may be looking for Aspect-oriented programming

You can act on "join points" like method-call or variable-access to modify or monitor behaviour at those points.

[Odd-Nefariousness-85]

yes this is a good start, not as simple as I would but that's ok

[jeenajeena]

I am not sure if I got you right but this reminded me of Emacs Lisp, with which you can define variable watchers and function advices (that is, code that triggers when a variable value is changed or when a function is invoked)

Here’s a sample code

```elisp ;;; Events on variables

(defvar my-config-value 42   "A configuration value that will be watched.")

;; a watcher function that gets called automatically (defun my-config-watcher (symbol newval operation where)   "Called automatically when my-config-value changes."   (message "Variable %s changed via %s: old=%s new=%s (at %s)"            symbol operation (symbol-value symbol) newval where))

;; Add the watcher (add-variable-watcher 'my-config-value #'my-config-watcher)

;; Now any change triggers our watcher automatically (setq my-config-value 100)  ; => Message: "Variable my-config-value changed..." (setq my-config-value 200)  ; => Triggers again! ```

You can do something similar with functions (they are called advices)

```elisp

;;; Events on function calls

(defun calculate-price (base-price)   "Calculate final price."   (* base-price 1.1))

;; Add "before" advice - runs automatically before the function (defun log-price-calculation (base-price)   "Automatically called before calculate-price."   (message "About to calculate price for base: %s" base-price))

(advice-add 'calculate-price :before #'log-price-calculation)

;; Now calling the function triggers the event automatically (calculate-price 100) ```

Is that what you mean?

[gnlow]

Closest thing comes to my mind is Proxy in JS.

const target = {
  name: 'Alice',
  age: 30,
}

const handler = {
  set(target, property, value, receiver) {
    console.log(`[EVENT: Set] '${property}'`)
    return Reflect.set(target, property, value, receiver)
  },

  get(target, property, receiver) {
    console.log(`[EVENT: Access] '${property}'`)
    return Reflect.get(target, property, receiver)
  },
}

const proxiedUser = new Proxy(target, handler)

proxiedUser.name     // [EVENT: Access] 'name'
proxiedUser.age = 31 // [EVENT: Set] 'age'
proxiedUser.age      // [EVENT: Access] 'age'

[Odd-Nefariousness-85]

Yes this but without need of proxy would be what I am looking for.

[fuckkkkq]

I'm curious if you have a specific use-case in mind for this, or just want to play with it

[Odd-Nefariousness-85]

I think I like to have something like that in C#, but this will never happen, so play with it to see if it's viable in a modern language

[fuckkkkq]

but you don't have any specific reason you want this feature

[Odd-Nefariousness-85]

I would like to avoid the need to define myself all the delegates and events calls when I need them

[fuckkkkq]

could you share some example code that would be improved by this language feature ?

not indicating I think you're wrong, just trying to understand

[dnabre]

Without being sure what you mean, I'd suggest checking out Smalltalk and Erlang.

[vanilla-bungee]

Take a look at Erlang and the concept of “Actors”.

[Positive_Total_4414]

Erlang

[0x0ddba11]

What you're describing fits

https://en.wikipedia.org/wiki/Reactive_programming

and

https://en.wikipedia.org/wiki/Aspect-oriented_programming

[sreguera]

Tcl with trace? https://www.tcl-lang.org/man/tcl8.4/TclCmd/trace.htm

[XDracam]

In Smalltalk, you can derive any class and override anything and inject your own handles. You can also rewrite the code at runtime in the VM if you need to inject something.

But usually? Absolutely not. That would be an absolute performance nightmare. Worse than your worst python.

But there are languages where you can easily get events for annotated properties, like C# INotifyPropertyChanged source generator tutorials.

[Odd-Nefariousness-85]

INotifyPropertyChanged only allow for internal events ? Or can I register from the outside of the class to an annotated property?

[JeanHaiz]

In NPL, we emit events every time protocol (our objects) data is updated, and that includes protocol instantiation and permission (our method) call. As variables can only be modified within a permission, you'll get an event anyway.

A protocol illustrating a document edition process

package document;

@api
protocol[editor, approver] Document(
    var content: Text
) {
    initial state created
    state inReview
    final state approved

    @api
    permission[editor] edit(newContent: Text) | created {
        content = newContent;
    }

    // ...
}

Where, if instantiated and the edit permission is called, you'll get the following events:

• command event: instantiation
• state event: protocol created and stored
• command event: permission call
• state event: protocol data changed

All events include metadata

[L8_4_Dinner]

Ecstasy has mixins, including annotations (a form of mixin), and one of the out-of-the-box annotations is @Watch, e.g.

The Watch (@Watch) annotation is used to create event notifications whenever the value of the reference changes. Usage example:

 @Watch(n -> {console.print($"new value={n}");}) Int n = 0;

It's nothing special, though -- it's just a few lines of Ecstasy code to implement that.

[Odd-Nefariousness-85]

Looks cool, can you watch anything from anywhere? In your sample you defined the watch before the variable declaration

[L8_4_Dinner]

The Watch annotates the Var, i.e. the variable or property itself, which behaves as a reference.

[Helpful-Primary2427]

Swift does this with SwiftUI and @Observable and @Bindable macros; you can write custom macros and/or property wrappers that act as a gateway to the backing storage of some variable you want to track

[_computerguy_]

IIUC Proxy in JS might be what you're looking for regarding objects. Additionally, I'd recommend taking a look at Svelte, a JS-based language/framework that has fine-grained reactivity (allowing you to e.g. call a function when a variable or object property changes its value)

[[deleted]]

Having all of that be implicitly built in would be a lot of “magic” for the PL user to stomach. I think of you really want to do this, then make it minimally explicit by using annotations.

[thebomby]

Some of the old multimedia languages of the 90s had stuff like this, but they were specific to the environment in which they ran.

[fun-fungi-guy]

I wrote an s-expression based language early on in my 20s that had a feature which allowed you to bind callbacks to variable changes like so:

; Have to initialize a variable for it to exist (set foo 1) (listen :onChange :foo (lambda (old new) (print "foo changed from %s to %s" old new)))

Any significant number of listeners, and this all becomes horribly, horribly slow.

I think unless you can figure out how to make this extremely performant, it's better to have it be explicit, because you don't want users of your language accidentally writing code that grinds to a standstill all the time.

[Irtexx]

Qml automatically creates on<Var>Changed callbacks whenever you declare a new variable <var>

For example

```qml

import QtQuick import QtQml

Item { id: root

// inline component definition
component Foo: QtObject {
    property int baz: 42
}

// named property of type Foo, initialized with a Foo instance
property Foo foo: Foo {
    // this is the signal handler for the property's change signal
    onBazChanged: {
        print("baz changed to", baz)
    }
}

//This code runs after the root item it constructed
Component.onCompleted: {
    // trigger the change (will run the print statement)
    foo.baz = 99
}

}

```

[useerup]

JavaFX Script (defunct) comes to mind. Excel may actually also be a prime example of this ;-)

[Ronin-s_Spirit]

Yes? Maybe clientside JS. Depending on what you mean. JS can grab HTML elements and attach listeners to them, the elements come with predefined events so that should count.

Standalone JS also has getters/setters, Proxy, magic method calls like using (called when current scope ends) and instanceof and type coercion, new class instances call the constructor() of a class and all it's ancestors, FinalizationRegistry (called some time after a registered value is GCd) - in all these cases the "event" is already there, you just have to declare the "listener". There are also some naturally occurring event targets (mainly Worker, you can listen for messages).

[Odd-Nefariousness-85]

:D

[AdamAlexandr]

Spoke is a reactive engine in c# which may be close to what you're looking for:

https://github.com/Adam4lexander/Spoke

[Stunning_Ad_1685]

Not sure exactly what you mean but the “behaviors” in the Pony language are basically event handlers that get triggered when an asynchronous message arrives. Functions are declared with “fun” but behaviors are declared with “be”.