Абстрактный адаптер аллюзий

Язык программирования Go (также известный как Golang) был создан в Google в 2007 году:

• Робертом Гриземером
• Робом Пайком
• Кеном Томпсоном

Язык был публично анонсирован в ноябре 2009 года, а версия 1.0 вышла в марте 2012 года.

Все три создателя были опытными системными программистами. Кен Томпсон — автор Unix и языка B, который оказал значительное влияние на Си. Роб Пайк работал над операционными системами Plan 9 и Inferno в Bell Labs. Роберт Гриземер трудился над компилятором Oberon вместе с Никлаусом Виртом, создателем языков Pascal и Modula-2, а позже внёс вклад в V8 JavaScript Engine — высокопроизводительный JS-движок, используемый в Google Chrome.

Так что генетика у языка Go правильная.

Перепишем на Gist алгоритм сопоставления строк с шаблоном из Снобола-4.

Реализация и три демонстрашки: snobol_patterns.gisp

Запускаем:

$ gisp snobol_patterns.gisp
== Snobol-style syllable split ==
syllable:
  matched: strand
  captures:
    onset => str
    nucleus => a
    coda => nd

== Configuration pairs with ARBNO/BREAK ==
pairs:
  matched: name = Alice; age=34; city=Rlyeh;
  captures:
    key => name
    value => Alice
    key => age
    value => 34
    key => city
    value => Rlyeh
  pairs:
    name => Alice
    age => 34
    city => Rlyeh

== Log line with LEN/POS/RPOS ==
log:
  matched: ERROR 2025-11-10 parser: unexpected token ';'
  captures:
    level => ERROR
    year => 2025
    month => 11
    day => 10
    date => 2025-11-10
    module => parser
    message => unexpected token ';'
  decoded date: 2025-11-10
  module: parser
  message: unexpected token ';'

Взял исходники игры 15 puzzle game на языке Scheme с rosettacode и перепёр на Gisp. Вроде ясный и понятный код получается. Всё в 200 строчек уложилось.

func playGame() {
    var board = createStartPosition()
    var movesTaken = 0
    while true {
        if finished(board) {
            newline()
            display("COMPLETED PUZZLE in ")
            display(movesTaken)
            display(" moves\n")
            return
        }
        displayBoard(board)
        var moves = findMoves(board)
        display("Enter a move: ")
        display(moves)
        newline()
        var move = read()
        if moveAllowed(moves, move) {
            makeMove(board, move)
            movesTaken = movesTaken + 1
        } else {
            display("Invalid move - try again\n")
        }
    }
}

Весь текст: puzzle15.gisp

Поиграем. В качестве хода надо вводить слова up/down/left/right.

$ gisp puzzle15.gisp 

   7  3  4  
2  11 8  12 
1  13 6  15 
5  9  14 10 
Enter a move: (down right)
down

2  7  3  4  
   11 8  12 
1  13 6  15 
5  9  14 10 
Enter a move: (up down right)
down

2  7  3  4  
1  11 8  12 
   13 6  15 
5  9  14 10 
Enter a move: (up down right)
right

...

1  2  3  4  
5  6  7  8  
9  10 11    
13 14 15 12 
Enter a move: (up down left)
down

COMPLETED PUZZLE in 50 moves

Полный протокол здесь: gist.github.com/sergev/2f8a65b7a11ea23a1693346a68a065d0

Мне с молодости импонировал Лисп (и Scheme) своим изяществом. Когда-то я даже стряпал эспериментальные реализации. Но глядеть на код со скобочками мало удовольствия. С удобным синтаксисом получается совсем другая песня.

В качестве проекта выходного дня залудил интерпретатор в стиле Scheme, но с синтаксисом типа Go. Получился весёлый язычок программирования:

func fact(n, acc) {
    if n == 0 {
        return acc;
    }
    return fact(n - 1, acc * n);
}

Полный тьюториал здесь: Gisp-Tutorial.md

Исходники: github.com/sergev/gisp

Полезная особенность языка Go - на нём отлично моделируется асинхронная логика. Суть там в 4-фазном протоколе. Подробности в моём старом посте.



На Go всякий такой сигнал от одного гейта к другому делается в виде пары каналов:

type Handshake[Treq any, Tack any] struct {
    Req chan Treq
    Ack chan Tack
}

По каналу запроса передаются значения в одну сторону, по каналу ответа - в обратную. Если нужен только сигнал, без всякого значения - передаём struct{} (аналог void). Вот пример реализации сложения двух чисел:

func AsyncAdder(a, b, sum *Handshake[int, struct{}]) {
    for {
        // Wait for inputs to arrive
        var x, y int
        haveA, haveB := false, false

        for !(haveA && haveB) {
            select {
            case x = <-a.Req:
                haveA = true
            case y = <-b.Req:
                haveB = true
            }
        }

        // Compute sum
        s := x + y

        // Send result downstream (Req↑)
        sum.Req <- s

        // Wait for output Ack↑
        <-sum.Ack

        // Only now acknowledge inputs (completing 4-phase handshake)
        a.Ack <- struct{}{}
        b.Ack <- struct{}{}
    }
}

Полный текст здесь: add.go



Интересно было бы сдизайнить цельный асинхронный процессор в таком виде, скажем riscv32. А потом засунуть в FPGA.