square_list([]) ->
[];
square_list([H | T]) ->
[H * H | square_list(T)].

contract SquareNumbers {
function squareList(uint[] memory numbers) public pure returns (uint[] memory) {
uint[] memory squares = new uint[](numbers.length);
for (uint i = 0; i < numbers.length; i++) { squares[i] = numbers[i] * numbers[i]; } return squares; } }

start(Port) ->
{ok, ListenSocket} = gen_tcp:listen(Port, [listening, {active, false}, {reuseaddr, true}]),
io:format(“WebSocket server listening on port ~p~n”, [Port]),
accept(ListenSocket).

accept(ListenSocket) ->
{ok, ClientSocket} = gen_tcp:accept(ListenSocket),
spawn(fun() -> init(ClientSocket) end),
accept(ListenSocket).

init(Socket) ->
send(Socket, “Welcome to the WebSocket server!”),
loop(Socket, []).

loop(Socket, Clients) ->
case gen_tcp:recv(Socket, 0) of
{ok, Data} ->
NewClients = [Socket | Clients],
broadcast(Data, NewClients),
loop(Socket, NewClients);
{error, closed} ->
io:format(“Client disconnected~n”),
lists:delete(Socket, Clients)
end.

broadcast(Message, Clients) ->
lists:foreach(fun(Client) -> send(Client, Message) end, Clients).

send(Socket, Message) ->
gen_tcp:send(Socket, Message).

contract WebSocketServer {
struct Client {
address clientAddress;
bool isConnected;
}

mapping(address => Client) public clients;
address[] public clientList;

function start() public {
// In Solidity, we can’t directly listen on a TCP port like in Erlang.
// This function would symbolize the initialization of the contract.
}

function accept(address clientAddress) public {
require(!clients[clientAddress].isConnected, “Client is already connected.”);
clients[clientAddress] = Client(clientAddress, true);
clientList.push(clientAddress);
init(clientAddress);
}

function init(address clientAddress) internal {
send(clientAddress, “Welcome to the WebSocket server!”);
// In Solidity, we do not have a direct loop for receiving messages,
// Instead, we will create a function that the client can call to send data.
}

function handleClient(address clientAddress, string memory data) public {
require(clients[clientAddress].isConnected, “Client is not connected.”);
broadcast(data);
}

function broadcast(string memory message) internal {
for (uint i = 0; i < clientList.length; i++) { send(clientList[i], message); } } function send(address clientAddress, string memory message) internal { // In Solidity, we can't send messages over TCP. // This function would symbolize sending a message. // You could emit an event instead. } function disconnect(address clientAddress) public { require(clients[clientAddress].isConnected, "Client is not connected."); clients[clientAddress].isConnected = false; // Remove client from clientList for (uint i = 0; i < clientList.length; i++) { if (clientList[i] == clientAddress) { clientList[i] = clientList[clientList.length - 1]; clientList.pop(); break; } } } }