0 what is this.md

collection of minimal Nim programs to accomplish simple tasks

keywords: Nim keywords: code snippets

calc md5 of string.nim

import md5
echo "Hello, world!".md5().toHex()

emit JSON.nim

import std/strformat

let payloadTxt: string = "TEST"
var json0 = &"{{\"type\":\"cmd\",\"payload\":\"{payloadTxt}\"}}"
echo json0

file write.md

https://glenngillen.com/learning-nim/write-file/

minimal example - channels.nim

# compile with    --threads:on 

import std/os # for sleep

var
  # create a channel to send/recv strings
  commChan: Channel[string]
  sender: Thread[void]
  recver: Thread[void]

proc sendMsg() =
  sleep(500)
  # send a message in the channel
  commChan.send("Hi")

proc recvMsg() =
  # block on the channel, waiting for output
  let msg: string = commChan.recv()
  echo "Received message: " & msg

# very important: channels must be opened before they can be used
commChan.open()
createThread(sender, sendMsg)
createThread(recver, recvMsg)
joinThreads(sender, recver)

minimal example - network UDP client.nim

import std/net



let socket = newSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
#socket.setBlocking(false)

var address: string = "0.0.0.0"
var port: int = 26098

socket.sendTo(address, Port(port), "status\n")


while true:
  var data: string
  let length: int = 2048
  var port2: Port
  let recvRes: int = recvFrom(socket, data, length, address, port2)

minimal example - z TCP server.nim

# from https://nim-lang.org/docs/asyncnet.html

import std/[asyncnet, asyncdispatch]

var clients {.threadvar.}: seq[AsyncSocket]

proc processClient(client: AsyncSocket) {.async.} =
  while true:
    let line = await client.recvLine()
    if line.len == 0: break
    for c in clients:
      await c.send(line & "\c\L")

proc serve() {.async.} =
  clients = @[]
  var server = newAsyncSocket()
  server.setSockOpt(OptReuseAddr, true)
  server.bindAddr(Port(12345))
  server.listen()
  
  while true:
    let client = await server.accept()
    clients.add client
    
    asyncCheck processClient(client)

asyncCheck serve()
runForever()

minimal net sync tcp client.nim

import std/[asyncnet, asyncdispatch]


# Create the socket
var socket = newAsyncSocket()


block:
  # Connect to the server
  let host = "127.0.0.1"
  let port: Port = Port(4466)
  waitFor socket.connect(host, port)
  echo "net: Connected to the server"


  var recvFuture: Future[system.string] = socket.recvLine()

  
  while true:
    poll(25)

    if recvFuture.finished:
      echo "DBG: recvFuture finished"

      if not recvFuture.failed:
        let recvMsg: string = recvFuture.read
        echo "net: recv=", recvMsg
      
      recvFuture = socket.recvLine()

minimum example - TCP client.nim

import std/[asyncnet, asyncdispatch]

proc asyncClient(host: string, port: Port, message: string) {.async.} =
  # Create the socket
  var socket = newAsyncSocket()

  try:
    # Connect to the server
    await socket.connect(host, port)
    echo "Connected to the server."

    # Send the message to the server
    await socket.send(message)
    echo "Message sent: ", message

    # Receive the response from the server
    #var response = newString(1024)
    #let bytesRead = await socket.recv(response, response.len)
    #response.setLen(bytesRead)
    var response: string = await socket.recvLine()

    echo "Response received: ", response

  except CatchableError as error:
    echo "Error: ", error.msg

  finally:
    # Close the connection
    socket.close()
    echo "Connection closed."

# Main procedure
proc main() =
  let host = "127.0.0.1"
  let port: Port = Port(12345)
  let message = "Hello, Server!"

  waitFor asyncClient(host, port, message)

main()

read binary content of file.nim

import system/io

# Open a binary file for reading
let input = open("textZ9584.txt.gz", fmRead)
let content = input.readAll()
input.close()

# Do something with the content
echo(content)

regex group.nim

# keywords: regex
# keywords: regular expression
# keywords: nim
# keywords: group matching

import re

let s = "22. YTTD kmkmkm"
let pattern = re"^\d+\. ([\w\s]+)$"
var matchesArr: array[2, string]
let matches = match(s, pattern, matchesArr)
if matches: # check if there is a match
  echo("match found")
  
  echo(matchesArr[0])
else:
  echo("No match found")