tomclose

module Lookups

  # Allows the definition of lookup values in a class.
  def define_lookup(klass_name, lookup_codes)

    # Ensure the classname conforms to convention
    klass_name = klass_name.to_s.classify

    # Add class methods
    klass = Class.new do

tomclose

class FruitImporter
  include HashRemapper

  remaps 'fruit_name',   to: :name
  remaps 'id',           to: :fruit_store_id
  remaps 'coordinates',  to: :coordinates_x, value: ->(c) { c[0].to_f if c}
  remaps 'coordinates',  to: :coordinates_y, value: ->(c) { c[1].to_f if c}
  
  def import(fruit_hash)
    Fruit.create(remap(fruit_hash))

tomclose

Simple timing

You can investigate how long something is taking using the Benchmark library.

require 'benchmark'

Benchmark.measure { some_code_I_want_to_profile }

tomclose

Keybase proof

I hereby claim:

• I am tomclose on github.
• I am tomclose (https://keybase.io/tomclose) on keybase.
• I have a public key ASCUBtXcn50zeVGwvfdpKEdIvjbco6XVEGYNMcRitbrZ_go

To claim this, I am signing this object:

tomclose

require 'benchmark'

def f_func(x); 2*x; end
def f_proc_func; proc {|x| 2*x}; end
f_proc_var = proc {|x| 2*x }

n = 1000000

Benchmark.bm(7) do |x|
  x.report("using function:            ") { n.times { |i| f_func(i) } }

tomclose

*.sol linguist-language=Solidity

tomclose

pragma solidity ^0.5.2;
pragma experimental ABIEncoderV2;

import "fmg-core/contracts/Commitment.sol";

library StateActionStyle {
  using Commitment for Commitment.CommitmentStruct;

  struct StateActionAttributes {
    address stateActionLibrary;

tomclose

tomclose

// in the adjudicator contract:

function respond(State memory s1, State memory s2) public {
    // check that the first state matches the stored challenge
    assertHashMatches(s1, stored_challenge_hash);
    
    // framework checks
    assertValidSignature(s2);
    assertSameAppDefinition(s1, s2);
    assertTurnNumIncrements(s1, s2);

tomclose

module Adjudicator {
  // the adjudicator explicitly declares the apps it supports
  import 0x32.Payments;
  import 0x34.Poker;
  // etc.
  
  public respond(adj: &mut R#Self.T, s1: &V#State, s2: &V#State) {
    // framework checks 
    // … (not shown) …