Brian Jaress's Blog

consumer

$ jest 6
lines: 1.5E+03    (from 3.8E+02 to 6.1E+03)

(define (generalize two-comp?)
  (define (gen-comp? . args)
    (if (or (null? args) (null? (cdr args)))
      #t
      (and (two-comp? (car args) (cadr args))
           (apply gen-comp? (cdr args)))))
  gen-comp?)

(define tasks (make-queue))
(queue-add! tasks 'clean-garage)
(queue-get! tasks)

(define make-hidden-queue
 (hide
  (queue make-queue)
  (unwrapped
   (add! queue-add!)
   (get! queue-get!))))

(define tasks (make-hidden-queue))

 (let-access (add! get!)
  (add! tasks 'clean-garage)
  (get! tasks))

(define make-bag
 (hide
  (bag make-tree-multiset)
  (unwrapped
   (add! tree-multiset-add!)
   (get! tree-multiset-extract-any!))))

(define other-tasks (make-bag))

(let-access (add! get!)
 (add! tasks 'clean-garage)
 (add! other-tasks (get! tasks))
 (get! other-tasks))

(hide
 (immutable-stack list)
 (unwrapped
  (peek car)
  (size length))
 (wrapped
  (push (lambda (stack item) (cons item stack)))
  (pop cdr)))

(define-syntax let-access
 ;Create a lexical scope in which certain names are bound to
 ;interface procedures, e.g.
 ;(let-access (add empty?) (if (empty? x) (add x val)))
 (syntax-rules ()
  ((let-access (symbol ...) body ...)
   (let ((symbol (lambda (x . args) (apply (x (quote symbol)) args))) ...)
    body ...))))

(define (make-accessor symbol)
 ;Create an accessor procedure.
 ;Useful when the symbol won't be known until runtime or the name
 ;is taken by an existing procedure
 (lambda (x . args) (apply (x symbol) args)))

(define-syntax hide
 ;Encapsulate a set of procedures over a "naked" data structure.
 ;The first subform is (interface-name constructor), and after that
 ;you can have any number of (type (name naked-accessor) ...) where the
 ;type is wrapped or unwrapped, e.g.
 ;(define make-heap (hide
 ; (heap make-reverse-garfinkle-heap)
 ; (unwrapped
 ;  (empty? rgh-empty?)
 ;  (insert! rgh-insert!)
 ;  (next! rgh-extract-next!))
 ; (wrapped (copy rgh-make-copy))))
 (syntax-rules (unwrapped wrapped)
  ((hide (interface-name constructor) subform ...)
   ;create wrapper that turns naked structure into encapsulated
   ;structure
   (letrec ((wrapper
    (lambda (naked)
     (lambda (symbol)
       (hide "subforms"
        (interface-name wrapper naked symbol) ;a.k.a. metadata
        subform ...)))))
    ;use the wrapper to return a modified constructor
    (lambda args (wrapper (apply constructor args)))))

  ((hide "subforms" metadata subform rest ...)
   ;recurse on subforms, passing each to the type-group processing
   (hide "type-group" metadata subform
    (hide "subforms" metadata rest ...)))

  ((hide "type-group" (interface-name wrapper naked symbol)
                      (type (name proc) ...)
                      subforms)
   ;each type-group becomes a case switch with the remaining subforms
   ;in the else clause
   (case symbol ('name (hide "procedure"
                        (interface-name wrapper naked symbol)
                        type proc)) ...
    (else subforms)))

  ((hide "subforms" (interface-name wrapper naked symbol))
    ;base case of recursion on subforms, fill in the right side of the
    ;final else clause
    (error "unknown interface symbol, no such accessor" symbol 'interface-name))

  ;The right sides of the case tests should be procedures that take a
  ;naked structure as the first argument.  The type (wrapped vs unwrapped)
  ;controlls whether the output of the provided procedure is wrapped in
  ;the same encapsulation before being returned.
  ((hide "procedure" (interface-name wrapper naked symbol)
                               wrapped proc)
   (lambda args (wrapper (apply proc (cons naked args)))))
  ((hide "procedure" (interface-name wrapper naked symbol)
                               unwrapped proc)
   (lambda args (apply proc (cons naked args))))))

buffer *
new_buffer ()
{
  buffer *buf = malloc (sizeof (buffer));
  buf->capacity = 100;
  buf->used = 0;
  buf->bytes = malloc (buf->capacity);
}

"""
Wrapped Tables extension for Markdown Python

2007-09-27

brian_jaress@gna.org

"Wrapped" means that you can wrap lines inside a cell.
It's inspired by another extension I found at

https://libprs500.kovidgoyal.net/browser/trunk/src/libprs500/ebooks/markdown/mdx_tables.py?format=txt

but that extension didn't have wrapping and is implemented in a very
different way.

An example of the syntax is:

|*heading*|*heading*|cell|
|cell a|cell b| cell c
    still cell c
    blah blah blah
    still cell c|
|third row|cell|cell|

That gives you a three by three table with two headings (top left and
top center) and one cell with a lot of text (mid right).

"""

from os import linesep
from csv import reader, QUOTE_NONE
from markdown import Preprocessor, Extension

class TableExtension(Extension):
    def __init__(self, configs):
        self.configs = {
                'delim': '|',
                'wrap': 4 * ' ',
                'header': '*'
                }
        self.configs.update(configs)

    def extendMarkdown(self, md, md_globals):
        md.preprocessors.append(TablePre(**self.configs))

class TablePre(Preprocessor):
    def __init__(self, delim, wrap, header):
        self.delim = delim
        self.wrap = wrap
        self.header = header

    def run(self, lines):
        table_lines = []
        #Group contiguous table lines and convert each group to a table
        for l in lines:
            if l.startswith(self.delim) or (len(table_lines) > 0 and
                    l.startswith(self.wrap)):
                table_lines.append(l)
            else:
                if len(table_lines) > 0:
                    for new_line in self.table(table_lines):
                        yield new_line
                    table_lines = []
                yield l

    def clean(self, cells):
        """Remove the empty cells at the beginning and end."""
        return cells[1:-1]

    def table(self, lines):
        yield "<table>"
        for r in self.parse(lines):
            yield self.row(r)
        yield "</table>"

    def parse(self, lines):
        """Generate table rows as lists of cell strings."""
        read = reader(lines,
                delimiter=self.delim,
                quoting=QUOTE_NONE,
                escapechar='\\',
                lineterminator=linesep
                )

        accumulated = []
        for line in read:
            if not line[0].startswith(self.wrap):
                #Start new row
                if len(accumulated) > 0:
                    yield self.clean(accumulated)
                accumulated = line
            else:
                #Continue existing cell
                accumulated[-1] = accumulated[-1] + '\n' + line[0].lstrip()
                accumulated.extend(line[1:])
        yield self.clean(accumulated)

    def row(self, data):
        return self.tag(''.join(map(self.cell, data)), "tr")

    def cell(self, data):
        if (data.startswith(self.header) and data.endswith(self.header) and
                len(data) > 1):
            data = data[len(self.header):-len(self.header)]
            tag = "th"
        else:
            tag = "td"
        return self.tag(data, tag)

    def tag(self, data, tag):
        return "<%s>%s</%s>" % (tag, data, tag)

def makeExtension(configs={}) :
    return TableExtension(configs)

/* Compute the next line number.  */

static void
next_line_num (void)
{
  char *endp = line_num_end;
  do
    {
      if ((*endp)++ < '9')
        return;
      *endp-- = '0';
    }
  while (endp >= line_num_start);
  if (line_num_start > line_buf)
    *--line_num_start = '1';
  else
    *line_buf = '>';
  if (line_num_start < line_num_print)
    line_num_print--;
}

Total Physical Source Lines of Code (SLOC)                = 19,611
Development Effort Estimate, Person-Years (Person-Months) = 4.55 (54.62)
Schedule Estimate, Years (Months)                         = 0.95 (11.43)
Please credit this data as "generated using David A. Wheeler's 'SLOCCount'."

$ jest-effort 19611
months: 15 (4 to 59)
people: 5 (1 to 21)

$ sloccount mac-3.99-u4-b4/src/Console mac-3.99-u4-b4/src/MACLib
Total Physical Source Lines of Code (SLOC)                = 7,642
Development Effort Estimate, Person-Years (Person-Months) = 1.69 (20.30)
Schedule Estimate, Years (Months)                         = 0.65 (7.85)
Please credit this data as "generated using David A. Wheeler's 'SLOCCount'."

$ jest-effort 7642
months: 11 (3 to 42)
people: 3 (1 to 10)

#type   elems   groups
ei      24      2       #External Input: the ape file
ilf     23      3       #Internal Logical File: ape metadata
ilf     1       1       #Internal Logical File: compressed sound

ilf     15      3       #wav header
ilf     1       1       #uncompressed sound
eo      16      2       #External Output: wav file

$ jest-lines <points.txt
4506

$ jest-lines --language haskell <points.txt
2771

$ jest-effort $(jest-lines <points.txt)
months: 9 (2 to 35)
people: 2 (0 to 7)

$ jest-effort $(jest-lines --language haskell <points.txt)
months: 7 (2 to 30)
people: 1 (0 to 5)

$ jest-effort --team=easy --language_experience=hard --documentation=hard $(jest-lines --language haskell <points.txt)
months: 8 (2 to 31)
people: 1 (0 to 6)

((email-address "___@___")
 (full-name "Brian Jaress")
 (geographic-location "Honolulu, HI, USA")
 (web-page-url "http://brian-jaress@livejournal.com")
 (statement-of-interest
"I'm a programmer who's fairly new to Scheme.

To me, the most important proposed changes in R6RS are the standard
module system and the standard libraries.  The core language in R5RS is
great, but the decision to use it always seems to create extra work
because of missing libraries.  There are extensions for most of the
basic things that usually come with a language (sorting, hash tables,
modules, etc.) but the fact that they are nonstandard creates extra work
of its own as far as compatibility and portability.

I haven't looked at every detail of the module system and libraries, but
they look a lot better than nothing.

One thing I'm not enthusiastic about in the current draft is the fact
that the built-in procedures are still not polymorphic.  For example,
having a single procedure called 'sort' that checks the type of the
argument to be sorted is perfectly possible.  It might be a little
faster to have a separate 'list-sort' and 'vector-sort,' but I don't
think it's worth it.  I also think there's no real benefit to explicitly
stating the type when you sort it.  When you're creating or using it,
maybe, but not when you're sorting it."))

;pairing heap represented as
;(parent newest-child second-newest-child ...)
(define (ph-min heap) (car heap))

;combine two heaps
(define (ph-link <? x y)
    (cond
        ((not (pair? x)) y)
        ((not (pair? y)) x)
        ((<? (car x) (car y)) (ph-link <? y x))
        (else (cons
            (car y)
            (cons x (cdr y))
        ))
    )
)

(define (ph-insert <? heap item) (ph-link <? heap (list item)))

;remove the smallest item
(define (ph-delmin <? heap)
    (let loop ((accum '()) (sibs (cdr heap)))
        (cond
            ((not (pair? sibs)) accum)
            (
                (not (pair? (cdr sibs)))
                (ph-link <? accum (car sibs))
            )
            (else (loop
                (ph-link <? (ph-link <? (car sibs) (cadr sibs)) accum)
                (cddr sibs)
            ))
        )
    )
)

(define (read-line) (let loop ((l "") (c (read-char)))
    (cond
        ((and (eof-object? c) (string=? l "")) c)
        ((or (eof-object? c) (char=? c #\newline)) l)
        (else (loop (string-append l (string c)) (read-char)))
    )
))

(define lineheap (let loop
    (
        (heap '())
        (l (read-line))
    )
    (if (not (eof-object? l))
        (loop (ph-insert string<? heap l) (read-line))
        heap
    )
))

(let loop ((heap lineheap))
    (if (pair? heap)
        (begin
            (display (ph-min heap))
            (newline)
            (loop (ph-delmin string<? heap))
        )
    )
)

#! /usr/bin/env python

#http://codekata.pragprog.com/2007/01/kata_six_anagra.html

from sys import stdin

def extract(word):
    letters = word.lower()
    return ''.join(sorted(list(letters)))

seen = {}

for line in stdin:
    word = line.strip()
    letters = extract(word)
    if letters not in seen:
        seen[letters] = []
    seen[letters].append(word)

for group in seen.values():
    if len(group) > 1:
        print ' '.join(group)

Brian Jaress's Blog

Jest 2.0 is in Beta

Making a Choice on Haskell

Taking a Second Look at Haskell: A Thread Pool for the Command Line

Defining "Less Than"

Comparisons

Options

Why

Moral and Code

A Trivial Un-Object System for Scheme

What I Wanted

How to Use It

How it Works

How It Works vs How to Work With It

Undergraduate C at UH

So what else do you need?

Controversy

Two Semesters of C

Lessons Learned

Valgrind

-Wall

C Turns Almost Every Error into a Memory Error

Software Engineering

Next Semester

Website Concepts

Caucus

Number Sequence Zendo

Artificial Evil

Morality by Multiplication

Rebuttal Roundup

Open the Pod Bay Doors, HAL

Jest 1.0

Why GPLv3?

What Next?

Markdown-Python Wrapped Tables Extension

A Substantive Look at Strategy Letter VI

Endnote

A Minor Problem with Strategy Letter VI

R6RS Ratified

The Grad Student

Why I Voted No

I'm a Member of the R6RS Electorate

HOSEF Looking for a New Partner

Think First, Then Program Into a Language

Antiblub

Think First

An Example

Choices

Jest Walk-Through

The Project

Existing Code

Function Points

Refinement

What Does It All Mean?

R6RS Ratification Registration

Functional Sorting in Scheme with Pairing Heaps

The Mysterious Kata