greister

struct Book {
    name: String
}

impl Book {
    fn show_book_name(&self) {
        println!("Name is : {}", self.name);
    }
}

greister

// http://rosettacode.org/wiki/Define_a_primitive_data_type
/// Implements a custom type named CustomInt.
/// One problem that I'm not sure how to solve is bounds checking on variable assignments.
/// This type only implements a subset of all traits within std::ops.
use std::ops;

#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Copy, Clone)]
pub struct CustomInt {
    value: u8,
}

greister

// Define a structure named `List` containing a `Vec`.

use std::fmt;
use std::ops::Deref;

struct List(Vec<i32>);

impl Deref for List {
    type Target = Vec<i32>;
    

greister

// incoming packet handler and reconnection thread
thread::spawn(move || {
            // get underlying tcpstream clone from connection object
            let mut _stream_pkt_hndlr_thrd = {
                let ref connection = *_client_pkt_hndlr_thrd.connection.lock().unwrap();
                let stream = match connection.stream {
                    Some(ref s) => s,
                    None => panic!("No stream found in the connectino"),
                };
                stream.try_clone().unwrap()

greister

use std::fmt::{Debug};
use std::ops::Add;
use std::num::{Zero, One};

trait Numeric : 'static + Debug + Clone + Zero + One { } 

}

impl<T> Numeric for T where T : 'static + Debug + Clone + Zero + One {  }

greister

use std::sync::{Arc, RwLock};
use std::collections::HashMap;
use std::hash::Hash;
use std::cmp::Eq;

trait SessionStore<K, V> {
    fn remove(&self, key: &K) -> bool;
}

type Store<K, V> = RwLock<HashMap<K, RwLock<V>>>;

greister

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import requests
#import urlextractor
import re
import string


# utils.py

greister

# -*- coding: utf-8 -*-
"""
Created on Thu Aug 11 15:55:44 2016

@author: Cat
"""

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import requests

greister

Static vs Dynamic dispatch

AKA: Why is consuming an Iterator from glutin so damn hard?

---

In Rust, like many other languages, there are two different ways to call a function: static and dynamic dispatch. They're used in different scenarios and each have their own pros and cons, which are summarised thusly:

1. Static calls tend to be faster because they do not require the use of a lookup table, which incurs overhead as the compiler has to 'find' the function it is calling at runtime.
2. Dynamic calls tend to be more conservative of space as they can be re-used. This isn't so much an issue with functions like strcpy, but with functions that have multiple types of arguments (generics, for example), the code for the function must be duplicated.

greister

;;; Try to find the string at point as a NodeJS module

(require 'ffap)

(defun ffap-nodejs-module (name)
  (unless (or (string-prefix-p "/" name)
              (string-prefix-p "./" name)
              (string-prefix-p "../" name))
    (let ((base (locate-dominating-file
                 default-directory