User:Gilbert189/Languages in concept

Agent-based esolangs

These are two of what I call "agent-based" languages. The main idea is there are agents (which could be anything, inorganic or not) with their certain traits that could communicate with each other.

Around this time, I like to make keywords first-class (that is, you can feed in keywords like print into a function).

Smalltalk-like

This variant resembles Smalltalk, at least in the looks. I don't really like this variant anymore, since for something that uses < to ask others, using parenthesis to feed outputs feels like a bad match. Oh well.

I agent: Main traits: [Runnable Stateful].
I use: "System:IO/Input" as: Input.
I use: "System:IO/Output" as: Output.
I use: "Toolbox:Operations/String" as: StringOP.

I on: run do: {
    put to: name value: (I < ask about: "What's your name?").
    if true: (StringOP < compare value: (get value: name) equals: "Gilbert") do: {
        Output < write text: "Hello, myself!".
    } else: {
        Output < write text: (StringOP < format text: "Hello, {}!" with: [(get value: name)]).
    }.
}.

I on: ask args: [about] do: {
    Output < write text: (get argument: about).
    answer with: (Input < read until: "\n").
}.

You could see this language being used in a digital thermostat that talks using MQTT:

I agent: Thermostat traits: [Periodic Stateful].
I use: "System:Environment" as Env.
I use: "Toolbox:Operations/Number" as: NumOP.
I use: "MQTT:example.mqtt:8883" as: MQTT config: [
    username: (Env < get var: "MQTT_USER")
    password: (Env < get var: "MQTT_PASS")
].
I use: "GPIO:Analog/0" as: LM35 config: [
    as: input
    output: voltage
].
I use: "GPIO:Digital/0" as: HeaterRelay config: [
    as: output
].
I use: "GPIO:Digital/1" as CoolerRelay config: [
    as: output
].


MQTT < subscribe to: "temperature/set/cool" do: {
    put to: coolTemp value: (get argument: value).
}.
MQTT < subscribe to: "temperature/set/heat" do: {
    put to: heatTemp value: (get argument: value).
}.

NumOP < addConversion from: 0.01V to: 1.degC context: tempConvert.
I on: tick do: {
    put to: temp value: (NumOP < convert: (LM35 < get) to: degC context: tempConvert).
    MQTT < publish to: "temperature/value" value: (NumOP < {
        scratch to: x value: (I < get value: temp).
        scratch to: x value: (NumOP < raw value: (get scratch: x)).
        scratch to: x value: (NumOP < stringify value: (get scratch: x)).
        answer with: (get scratch: x).
    }).
    if true: (NumOP < compare value: (get value: temp) greater: (get value: coolTemp)) do: {
        CoolerRelay < set to: high.
    } else: {
        CoolerRelay < set to: low.
    }.
    if true: (NumOP < compare value: (get value: temp) less: (get value: heatTemp)) do: {
        HeaterRelay < set to: high.
    } else: {
        HeaterRelay < set to: low.
    }.
}

Simplified

This is a simplified version of last language. As you can read, it uses it as an accumulator for the next instruction.

Still need to figure out what the parenthesis and brackets differ.

agent Main traits [Runnable Stateful].
-- Runnable: this agent can be run from an outside initiator (e.g. your terminal)
-- Stateful: this agent stores some states (defines the actions [(set name) (to value)] and [(get name)])

use "IO:Output" as Output.
use "Number:Operations" as Number-OP.
use "Text:Operations" as Text-OP.
-- The syntax for the agent selector are "Protocol:Link/To/Agent"
-- Each protocol has their own unique actions.

-- This defines an action which can be asked by other agents.
-- For this one, it also acts as the entry point for the initiator.
on [(run args)] do {
	set i to 1.

	-- Repeatedly does the instructions until a reply is given.
	loop {
		set out to "".

		get i. ask Number-OP to {mod it with 3. reply it.}.
		if it is 0 do {
			get out. ask Text-OP to {add it with "Fizz". reply it.}. set out to it.
		}.
		get i. ask Number-OP to {mod it with 5. reply it.}.
		if it is 0 do {
			get out. ask Text-OP to {add it with "Buzz". reply it.}. set out to it.
		}.

		get out.
		if it is "" do {
			ask Number-OP to {textify it. reply it.}.
			ask Output to {write it. reply it.}.
		}.
		
		get i. ask Number-OP to {add it with 1. reply it.}. set i to it.

		get i. ask Number-OP to {compare it with 100. reply it.}.
		-- Number-OP's compare action replies the flags [equal greater less].
		if it is equal do {
			reply 0.
		}.
	}.
	reply it.
}.

Smalltalk-like version 2

Made in 17 July 2024.

This one follows the previous Smalltalk-like syntax, but written in the way I envisioned it to be.

agent: Example traits: [runnable]
use: sys/terminal as: Terminal
use: lang/text as: TextOP

on: main do: {
    define var: name.
    ask about: "What is your name? " > (name).
    TextOP < compare value: (name) equals: "Gilbert" > if true: () do: {
        print text: "Hello, myself!".
    } else: {
        TextOP < format pattern: "Hello, {}." with: [(name)] > print text: ().
    }.
 }

on: print args: [text] do: {
    Terminal < write line: (text).
}

on: ask args: [about] do: {
    Terminal < {
        write line: (about).
        read until: "\n" > answer with: ().
    } > answer with: ().
}

Note the runnable written in lowercase: this is an added lore to this language (more of a retcon really) where initially this language is read in a machine that's case insensitive (like COBOL!)

Here's an example of how a simulator might run the above script.

$ aasim -x example.agent
What is your name? Hale
Hello, Hale.
$ aasim -x example.agent -vv
[INFO] Starting agent Example
[DEBUG] Sys/Terminal: [INFO] Starting agent Sys/Terminal as required by Example
[DEBUG] Lang/Text: [INFO] Starting agent Lang/Text as required by Example
[DEBUG] Sys/Terminal: [INFO] Started agent Sys/Terminal as required by Example
[DEBUG] Lang/Text: [INFO] Started agent Lang/Text as required by Example
[DEBUG] Started agent Example
[DEBUG] Calling Example to do `main`
What is your name? Gilbert189
Hello, myself!
[DEBUG] `main` answered with null
[INFO] Stopping agent Example
[DEBUG] Sys/Terminal: [INFO] Stopping agent Sys/Terminal
[DEBUG] Stopped agent Example
[DEBUG] Lang/Text: [INFO] Stopping agent Lang/Text
[DEBUG] Sys/Terminal: [INFO] Stopped agent Sys/Terminal
[DEBUG] Lang/Text: [INFO] Stopped agent Lang/Text
$

Here's an example of an agent that uses Example for their purpose.

agent: RemoteExample traits: [runnable]
use: Example as: Example
use: lang/text as: TextOP

on: main do: {
    Example < {
        ask about: "Input anything. " 
        > TextOP < format "Got input {}" with [()]
        > print text: ().
    }
}

And here's how it runs in the simulator:

$ aasim remote-example.agent -vv
[INFO] Starting agent RemoteExample
[DEBUG] Example: [INFO] Starting agent Example as required by RemoteExample
[DEBUG] Sys/Terminal: [INFO] Starting agent Sys/Terminal as required by Example
[DEBUG] Lang/Text: [INFO] Starting agent Lang/Text as required by Example
[DEBUG] Sys/Terminal: [INFO] Started agent Sys/Terminal as required by Example
[DEBUG] Lang/Text: [INFO] Started agent Lang/Text as required by Example
[DEBUG] Example: [INFO] Started agent Example
[DEBUG] Started agent RemoteExample
[DEBUG] Calling RemoteExample to do `main`
Input anything. 2763
Got input 2763
[DEBUG] `main` answered with null
[INFO] Stopping agent RemoteExample
[DEBUG] Example: [INFO] Stopping agent Example
[DEBUG] Sys/Terminal: [INFO] Stopping agent Sys/Terminal
[DEBUG] Example: [INFO] Stopped agent Example
[DEBUG] Lang/Text: [INFO] Stopping agent Lang/Text
[DEBUG] Sys/Terminal: [INFO] Stopped agent Sys/Terminal
[DEBUG] Stopped agent RemoteExample
[DEBUG] Lang/Text: [INFO] Stopped agent Lang/Text
$

Here's another agent that demonstrates concurrency in this language:

agent: ForkedRandom
use: lang/number as: NumberOP

on: get-one do: {
    NumberOP < random from: 0.0 to: 1.0 > answer with: ().
}

on: get-three do: {
    -- Parallel commands can be done with vertical lines...
    NumberOP < random from: 0.0 to: 1.0 | NumberOP < random from: 0.0 to: 1.0 | NumberOP < random from: 0.0 to: 1.0 
    > answer with: [(0) (1) (2)].
}

on: get-five do: {
    -- ...or with double brackets.
    {{
        NumberOP < random from: 0.0 to: 1.0.
        NumberOP < random from: 0.0 to: 1.0.
        NumberOP < random from: 0.0 to: 1.0.
        NumberOP < random from: 0.0 to: 1.0.
        NumberOP < random from: 0.0 to: 1.0.
    }} > answer with: [(0) (1) (2) (3) (4)].
}

As this agent doesn't have the trait runnable, we would have to use another way to interact with this agent.

$ aasim -x random.agent
[ERROR] Agent ForkedRandom has no trait `Runnable`
$ aasim random.agent # -s implies -v
[INFO] Starting agent ForkedRandom
[1]+  Stopped                aasim -s random.agent
$ bg
[1]+ aasim -s random.agent &
$ aasim ForkedRandom
You are now commanding ForkedRandom.
< get-one
> 0.378571834
< get-three
> [0.930591305 0.678678690 0.285028494]
< get-five
> [0.498587492 0.184080535 0.469049644 0.704954824 0.901419385]
< get-seven
[ERROR] ForkedRandom doesn't implement `get-seven`.
< ^C
You stopped commanding ForkedRandom.
$ aasim Blah
[ERROR] Agent Blah not found.
$