Namespace: go.std.hash.maphash
v1.0Contents
Summary
Provides a lowlevel interface to the hash/maphash package.
Package maphash provides hash functions on byte sequences.
These hash functions are intended to be used to implement hash tables or
other data structures that need to map arbitrary strings or byte
sequences to a uniform distribution on unsigned 64bit integers.
The hash functions are collisionresistant but not cryptographically secure.
(See crypto/sha256 and crypto/sha512 for cryptographic use.)
The hash value of a given byte sequence is consistent within a
single process, but will be different in different processes.
Index
Legend

Constant
Variable
Function
Macro
Special form
GoType
GoVar
Receiver/Method
Constants
Constants are variables with :const true in their metadata. Joker currently does not recognize them as special; as such, it allows redefining them or their values.
(None.)
Variables

(None.)
Functions, Macros, and Special Forms

MakeSeed
Function v1.0(MakeSeed)
MakeSeed returns a new random seed.
Go return type: Seed
Joker input arguments: []
Joker return type: go.std.hash.maphash/Seed
Types

*Hash
Concrete GoType v1.0 
BlockSize
Receiver for *Hash v1.0([])
BlockSize returns h's block size.

Seed
Receiver for *Hash v1.0([])
Seed returns h's seed value.

Size
Receiver for *Hash v1.0([])
Size returns h's hash value size, 8 bytes.

Sum64
Receiver for *Hash v1.0([])
Sum64 returns h's current 64bit value, which depends on
h's seed and the sequence of bytes added to h since the
last call to Reset or SetSeed.
All bits of the Sum64 result are close to uniformly and
independently distributed, so it can be safely reduced
by using bit masking, shifting, or modular arithmetic.

WriteByte
Receiver for *Hash v1.0([b])
WriteByte adds b to the sequence of bytes hashed by h.
It never fails; the error result is for implementing io.ByteWriter.

WriteString
Receiver for *Hash v1.0([s])
WriteString adds the bytes of s to the sequence of bytes hashed by h.
It always writes all of s and never fails; the count and error result are for implementing io.StringWriter.

*Seed
Concrete GoType v1.0 
Hash
Concrete GoType v1.0A Hash computes a seeded hash of a byte sequence.
The zero Hash is a valid Hash ready to use.
A zero Hash chooses a random seed for itself during
the first call to a Reset, Write, Seed, Sum64, or Seed method.
For control over the seed, use SetSeed.
The computed hash values depend only on the initial seed and
the sequence of bytes provided to the Hash object, not on the way
in which the bytes are provided. For example, the three sequences
h.Write([]byte{'f','o','o'})
h.WriteByte('f'); h.WriteByte('o'); h.WriteByte('o')
h.WriteString("foo")
all have the same effect.
Hashes are intended to be collisionresistant, even for situations
where an adversary controls the byte sequences being hashed.
A Hash is not safe for concurrent use by multiple goroutines, but a Seed is.
If multiple goroutines must compute the same seeded hash,
each can declare its own Hash and call SetSeed with a common Seed.

Seed
Concrete GoType v1.0A Seed is a random value that selects the specific hash function
computed by a Hash. If two Hashes use the same Seeds, they
will compute the same hash values for any given input.
If two Hashes use different Seeds, they are very likely to compute
distinct hash values for any given input.
A Seed must be initialized by calling MakeSeed.
The zero seed is uninitialized and not valid for use with Hash's SetSeed method.
Each Seed value is local to a single process and cannot be serialized
or otherwise recreated in a different process.