25 Matching Annotations
  1. Dec 2022
  2. Nov 2022
    1. by using symbols as keys, you will be able to use the implicit conversion of a Mash via the #to_hash method to destructure (or splat) the contents of a Mash out to a block

      This doesn't actually seem to be an example of destructure/splat. (When it said "destructure the contents ... out to a block", I was surprised and confused, because splatting is when you splat it into an argument or another hash — never a block.)

      An example of destructure/splat would be more like

      method_that_takes_kwargs(**symbol_mash)

  3. Jul 2022
  4. Jun 2022
  5. May 2022
    1. hash the source/destination IP:port tuples to the same worker thread.

      hash the source/destination IP:port tuples to the same worker thread.

    1. http://geohash.org/c216ne:Mt_Hood http://geohash.org/?q=45.37,-121.7&format=gpx http://geohash.org/?q=45.37,-121.7&format=url&redirect=0

      • osm — open the location in OpenStreetMaps
      • gmaps — open the location in Google Maps
      • gc — go to the nearest geocaches in Geocaching.com
      • gpx — go directly to GPX download page
      • garmin — go directly to Garmin download page
      • text — show coordinates as plain text
      • url — show Geohash URL as plain text
      • maxlen — maximum length of the Geohash
    1. hash://sha256/9f86d081884c7d659a2feaa0?type=text/plain#top \__/ \____/ \______________________/ \_____________/ \_/ | | | | | scheme algorithm hash query fragment

  6. Jan 2022
  7. Mar 2021
    1. A proposal to specify the path for bury with classes as values of a hash arg: {}.bury(users: Array, 0 => Hash, name: Hash, something: 'Value') # {user: [{name: {something: 'Value'}]} So all absent nodes could be created via klass.new

      Didn't understand it at first, but now I think it's a pretty clever/decent solution.

      Just a bit more verbose than one might like...

      At first I had reservations about the fact that this requires you to pass a hash ... or rather, once you start using a hash as your "list", you can't just "switch back" to an array (a "problem" I've noticed in RSpec, where you have some tags that are symbols, and some that are hashes: you have to list the symbols first: describe 'thing', :happy_path, driver: :chrome):

      {}.bury(users: Array, 0, 'Value')
      

      But I think that's okay in practice. Just use a hash for all "elements" in your list:

      {}.bury(users: Array, 0 => 'Value')
      
  8. Feb 2021
    1. The problem is that you what you want is actually not de-structuring at all. You’re trying to go from 'arg1', { hash2: 'bar', hash3: 'baz' }, { hash1: 'foo' } (remember that 'arg1', foo: 'bar' is just shorthand for 'arg1', { foo: 'bar' }) to 'arg1', { hash1: 'foo', hash2: 'bar', hash3: 'baz' } which is, by definition, merging (note how the surrounding structure—the hash—is still there). Whereas de-structuring goes from 'arg1', [1, 2, 3] to 'arg1', 1, 2, 3
    1. {a: 1, b: 2, c: 3, d: 4} => {a:, b:, **rest} # a == 1, b == 2, rest == {:c=>3, :d=>4}

      equivalent in javascript:

      {a, b, ...rest} = {a: 1, b: 2, c: 3, d: 4}
      

      Not a bad replacement for that! I still find javascript's syntax a little more easily readable and natural, but given that we can't use the same syntax (probably because it would be incompatible with existing syntax rules that we can't break for compatibility reasons, unfortunately), this is a pretty good compromise/solution that they've come up with.

  9. Oct 2020
  10. Jan 2020
  11. Oct 2018
    1. 8. Examples 8.1. Hello World! The following ni URI is generated from the text "Hello World!" (12 characters without the quotes), using the sha-256 algorithm shown with and without an authority field: ni:///sha-256;f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk ni://example.com/sha-256;f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk The following HTTP URL represents a mapping from the previous ni name based on the algorithm outlined above. http://example.com/.well-known/ni/sha-256/ f4OxZX_x_FO5LcGBSKHWXfwtSx-j1ncoSt3SABJtkGk
  12. Feb 2018
    1. imgHash.py

      具体实现:

      #!/usr/bin/python
      
      import glob
      import os
      import sys
      
      from PIL import Image
      
      EXTS = 'jpg', 'jpeg', 'JPG', 'JPEG', 'gif', 'GIF', 'png', 'PNG'
      
      def avhash(im):
          if not isinstance(im, Image.Image):
              im = Image.open(im)
          im = im.resize((8, 8), Image.ANTIALIAS).convert('L')
          avg = reduce(lambda x, y: x + y, im.getdata()) / 64.
          return reduce(lambda x, (y, z): x | (z << y),
                        enumerate(map(lambda i: 0 if i < avg else 1, im.getdata())),
                        0)
      
      def hamming(h1, h2):
          h, d = 0, h1 ^ h2
          while d:
              h += 1
              d &= d - 1
          return h
      
      if __name__ == '__main__':
          if len(sys.argv) <= 1 or len(sys.argv) > 3:
              print "Usage: %s image.jpg [dir]" % sys.argv[0]
          else:
              im, wd = sys.argv[1], '.' if len(sys.argv) < 3 else sys.argv[2]
              h = avhash(im)
      
              os.chdir(wd)
              images = []
              for ext in EXTS:
                  images.extend(glob.glob('*.%s' % ext))
      
              seq = []
              prog = int(len(images) > 50 and sys.stdout.isatty())
              for f in images:
                  seq.append((f, hamming(avhash(f), h)))
                  if prog:
                      perc = 100. * prog / len(images)
                      x = int(2 * perc / 5)
                      print '\rCalculating... [' + '#' * x + ' ' * (40 - x) + ']',
                      print '%.2f%%' % perc, '(%d/%d)' % (prog, len(images)),
                      sys.stdout.flush()
                      prog += 1
      
              if prog: print
              for f, ham in sorted(seq, key=lambda i: i[1]):
                  print "%d\t%s" % (ham, f)
      

      参考代码:

      1. http://www.ruanyifeng.com/blog/2011/07/imgHash.txt
  13. Sep 2017