durka

coi lo jbopre

My name is Dustin and you might know me as ldlework or mokau or cadgu'a.  I'm
writing to announce the current motion to nominate selpa'i as the current warden
for the language in a provisionally offical capacity contingent on the general
attitudes professed by the community's response to the motion. selpa'i would be
replacing Robin Lee Powell in this position.

Currently, the IRC and Facebook communities have been approached. The response so
far has been extremely positive with a current count of 20 to 1 in favor of the

durka

Dustin Lacewell

selpa'i AKA Lorenzo Von Matterhorn has just been nominated in the #lojban channel
as standing BDFL with a current approval of 8/8 votes thus far. If this is an
important matter to you, which I'm sure it is, please join us in the IRC channel
to convey your approval or disapproval with this motion. Thanks!

EDIT:

The current total is 21 to 1 in support for selpahi as new acting warden for the

durka

------ yea's (25)

2014-05-13 16:06:40	durka42	I would second what ldlework said, though from sy's blog I thought it had already gotten close to happening and then fallen apart

2014-05-13 16:16:19	zahlman	thirded.

2014-05-13 16:21:02	kantu	well I also endorse the nomination, if it means anything

2014-05-13 16:21:34	danr	4th!

durka

I marked any mistakes I found and put markers at the beginning of each line containing corrections.

legend:
G = experimental grammar (marks things not in CLL, except dotside and kujoi)
E = error (i.e. should be fixed even in the Modern Lojban version)
W = warning (not error; style or something)

Things I didn't mark because of too many occurrences:
     - replace "je cu" with "gi'e" everywhere
     - replace "jau" with "jo'u" everywhere (except not inside lujvo)

durka

//! Shows how to construct a closure that captures a Sender while still implementing Sync
//! This is nontrivial because you can't directly share a Sender across threads, so a Mutex is required

use std::sync::mpsc::{channel, Sender};
use std::sync::Mutex;
use std::thread;

/// Something to send across threads
#[derive(Debug)]
enum Message { A, B }

durka

// due to Enamex on #rust

macro_rules! overload {
    ( $trait_name:ident ($($args:ident : $typs:ty),+) => $( fn $fn_name:ident -> $ret:ty => $body:block );+ ) => {
        overload!(INTERNAL:DUPLICATE $trait_name ( ($($args),+) ($($args),+) : ($($typs),+) ($($typs),+) ) => $( fn $fn_name -> $ret => $body );+ );
    };
    
    (INTERNAL:DUPLICATE $trait_name:ident ( $all_args:tt ($($args:ident),+) : $all_typs:tt ($($typs:ty),+) ) => $( fn $fn_name:ident -> $ret:ty => $body:block );+ ) =>
    
    {

durka

macro_rules! as_item {
    ($i:item) => ($i);
}

macro_rules! struct_with_constructor {
    (
        $(#[$meta:meta])*
        struct $name:ident {
            $($arg:ident : $typ:ty),*;
            $(fn $fn_name:ident $args:tt $(-> $ret_ty:ty)* { $($fn_body:tt)* })*

durka

trait Associated<T> {
    fn associated(&self) -> T;
}

trait Thing : Associated<&'static str> {
    fn whatever(&self);
}

macro_rules! associated {
    ($t:ident, $val:expr => $typ:ty) => {

durka

#![allow(dead_code)]

macro_rules! as_item { ($i:item) => ($i) }

macro_rules! s {
    ($t:ident) => {
        impl $t {
        }
    };
    ($t:ident<$($x:tt),+>) => {

durka

trait GetSet<G,S> {
    fn get(&self) -> G;
    fn set(&self) -> S;
}

macro_rules! field {
    ($s:ident . $f:ident) => ($s.get().$f(&$s));
    ($s:ident . $f:ident = $v:expr) => ($s.set().$f(&mut $s, $v));
    
    (