sma

Mutationen

Gegeben ist dieses Programm:

class C:
    def f(self, a):
        b = a
        self.c = b

h(self.g)

sma

import web

class Page(web.Page):
    def create(self):
        class ClickCounter(object):
            def __init__(self):
                self.clicks = 0

        counter = ClickCounter()

sma

from os import urandom

def random_id():
    """Returns a 20-character random identifier."""
    return urandom(15).encode("base64")[:-1]

def parse_cookie(environ):
    """Returns the cookie from the given WSGI environ as dict."""
    s = environ.get('HTTP_COOKIE', '')
    return dict(map(str.strip, elt.split("=")) for elt in s.split(";")) if s else {}

sma

import web

class HelloWorld(web.Page):
    def create(self):
        self.add(web.Label("message", "Hello World"))
    
    html = """<span web:id="message">Message goes here</span>"""

web.start(HelloWorld)

sma

def fail():
  "Returns a parser that fails on every input."
  return lambda s: None
 
def char(c):
  "Returns a parser that matches 'c' and fails otherwise."
  return lambda s: (s[1:], c) if s and s[0] == c else None
 
def alt(p1, p2):
  "Returns a parser that applies either parser 'p1' or 'p2'."

sma

Webapps a la Seaside

Ich will versuchen, die Essenz von Seaside in Python-Syntax zu übertragen.

Anwendungen werden aus Komponenten zusammengesetzt. Klassen beschreiben diese Komponenten. Die Klassen werden an URLs gebunden. Wird so eine URL angesprochen, wird eine neue Komponente erzeugt und für diesen Anwender in eine Session gepackt, wo sie solange lebt, die Session explizit oder durch einen Timeout beendet wird.

Das Rahmenwerk ruft für jede Komponente die Methode render auf. Diese ist dafür zuständig, die Komponte zu "zeichnen", sprich, das HTML durch Aufrufe von Methoden des übergebenen html-Objekts zu erzeugen.

class HelloWorld(seaside.Component):

sma

# encoding: UTF-8

rooms = {}

class Room(object):
    def __init__(self, name, description):
        self.name, self.description, self.exits, self.items = name, description, {}, []
        rooms[name] = self
    
    def look(self):

sma

import re

__all__ = ['Template', 'tag', 'filter', 'escape']

def Template(source):
    tokens = r'\{%(?:"[^"]*"|[^"]+?)*?%\}\s*|\{\{(?:"[^"]*"|[^"]+?)*?\}\}|[^{]+|\{'
    return Block(None, iter(re.findall(tokens, source)))

tags, filters = {}, {}

sma

import re
 
class Serializer(object):
    def __init__(self):
        self.s, self.r = "", {}
 
    def write(self, o):
        self.s += self.to_s(o); return self.s
    
    def to_s(self, o):

sma

Keiner hat die ursprüngliche Frage beantwortet. Das möchte ich nachholen.

Wie baut man denn nun eine eigene Sprache - egal ob mit deutschen oder englischen Schlüsselwörtern?

Ich stelle informell eine einfache Programmiersprache mit Präfixnotation vor, zeige wie man einen Scanner für Wörter dieser Sprache baut, einen Parser, der geklammerte Blöcke erkennt und einen Interpreter, der Wörter ausführen kann. Nicht unbedingt in dieser Reihenfolge.

Meine Sprache

Hier sind Beispiele in meiner Sprache: