| Package | Description |
|---|---|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.io |
Provides classes and static methods that make object and primitive-type I/O easier and faster.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Class and Description |
|---|
| AbstractByte2BooleanFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2BooleanMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2BooleanSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ByteFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ByteMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ByteSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2CharFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2CharMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2CharSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2DoubleFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2DoubleMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2DoubleSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2FloatFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2FloatMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2FloatSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2IntFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2IntMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2IntSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2LongFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2LongMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2LongSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ObjectFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ObjectMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ObjectSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ReferenceFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ReferenceMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ReferenceSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ShortFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ShortMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ShortSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByteBidirectionalIterator
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractByteBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractByteBigListIterator
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteComparator
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractByteList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractByteListIterator
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractBytePriorityQueue
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractByteSet
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractByteSortedSet
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| Byte2BooleanArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2BooleanAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2BooleanFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2BooleanFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2BooleanFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2BooleanFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2BooleanLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2BooleanMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2BooleanMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2BooleanMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2BooleanMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2BooleanMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2BooleanMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2BooleanMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2BooleanOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2BooleanOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2BooleanRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2BooleanSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2BooleanSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2ByteArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ByteAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ByteFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ByteFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2ByteFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2ByteFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2ByteFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2ByteLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ByteMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ByteMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ByteMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2ByteMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2ByteMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2ByteMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2ByteMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2ByteOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ByteOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ByteRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ByteSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ByteSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2ByteSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2CharArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2CharAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2CharFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2CharFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2CharFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2CharFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2CharFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2CharLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2CharMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2CharMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2CharMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2CharMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2CharMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2CharMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2CharMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2CharOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2CharOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2CharRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2CharSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2CharSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2CharSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2DoubleArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2DoubleAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2DoubleFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2DoubleFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2DoubleFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2DoubleFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2DoubleFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2DoubleLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2DoubleMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2DoubleMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2DoubleMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2DoubleMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2DoubleMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2DoubleMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2DoubleMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2DoubleOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2DoubleOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2DoubleRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2DoubleSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2DoubleSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2DoubleSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2FloatArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2FloatAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2FloatFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2FloatFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2FloatFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2FloatFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2FloatFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2FloatLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2FloatMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2FloatMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2FloatMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2FloatMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2FloatMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2FloatMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2FloatMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2FloatOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2FloatOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2FloatRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2FloatSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2FloatSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2FloatSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2IntArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2IntAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2IntFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2IntFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2IntFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2IntFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2IntFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2IntLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2IntMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2IntMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2IntMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2IntMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2IntMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2IntMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2IntMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2IntOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2IntOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2IntRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2IntSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2IntSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2IntSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2LongArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2LongAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2LongFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2LongFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2LongFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2LongFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2LongFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2LongLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2LongMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2LongMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2LongMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2LongMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2LongMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2LongMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2LongMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2LongOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2LongOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2LongRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2LongSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2LongSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2LongSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2ObjectArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ObjectAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ObjectFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ObjectFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2ObjectFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2ObjectFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2ObjectFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2ObjectLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ObjectMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ObjectMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ObjectMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2ObjectMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2ObjectMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2ObjectMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2ObjectMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2ObjectOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ObjectOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ObjectRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ObjectSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ObjectSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2ObjectSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2ReferenceArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ReferenceAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ReferenceFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2ReferenceFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2ReferenceFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2ReferenceFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2ReferenceLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ReferenceMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ReferenceMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2ReferenceMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2ReferenceMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2ReferenceMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2ReferenceMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2ReferenceOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ReferenceOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ReferenceRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ReferenceSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2ReferenceSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Byte2ShortArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ShortAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ShortFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ShortFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Byte2ShortFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Byte2ShortFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Byte2ShortFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Byte2ShortLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ShortMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ShortMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ShortMap.FastEntrySet
An entry set providing fast iteration.
|
| Byte2ShortMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Byte2ShortMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Byte2ShortMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Byte2ShortMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Byte2ShortOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ShortOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ShortRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ShortSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ShortSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Byte2ShortSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| ByteArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
| ByteArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ByteArrays.Segment |
| ByteArraySet
A simple, brute-force implementation of a set based on a backing array.
|
| ByteBidirectionalIterator
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| ByteBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ByteBigList
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteBigListIterator
A type-specific
BigListIterator . |
| ByteBigListIterators.EmptyBigListIterator
A class returning no elements and a type-specific big list iterator interface.
|
| ByteBigLists.EmptyBigList
An immutable class representing an empty type-specific big list.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteCollections.EmptyCollection
An immutable class representing an empty type-specific collection.
|
| ByteCollections.SynchronizedCollection
A synchronized wrapper class for collections.
|
| ByteCollections.UnmodifiableCollection
An unmodifiable wrapper class for collections.
|
| ByteComparator
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| ByteHash.Strategy
A type-specific hash strategy.
|
| ByteHeapSemiIndirectPriorityQueue
A type-specific heap-based semi-indirect priority queue.
|
| ByteIndirectPriorityQueue
A type-specific
IndirectPriorityQueue . |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| ByteIterators.EmptyIterator
A class returning no elements and a type-specific iterator interface.
|
| ByteLinkedOpenCustomHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ByteLinkedOpenHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ByteList
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteListIterator
A type-specific bidirectional iterator that is also a
ListIterator . |
| ByteLists.EmptyList
An immutable class representing an empty type-specific list.
|
| ByteLists.SynchronizedList
A synchronized wrapper class for lists.
|
| ByteLists.UnmodifiableList
An unmodifiable wrapper class for lists.
|
| ByteOpenCustomHashSet
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| ByteOpenHashSet
A type-specific hash set with with a fast, small-footprint implementation.
|
| BytePriorityQueue
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteSet
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteSets.EmptySet
An immutable class representing the empty set and implementing a type-specific set interface.
|
| ByteSets.Singleton
An immutable class representing a type-specific singleton set.
|
| ByteSets.SynchronizedSet
A synchronized wrapper class for sets.
|
| ByteSets.UnmodifiableSet
An unmodifiable wrapper class for sets.
|
| ByteSortedSet
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteSortedSets.EmptySet
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| ByteStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractByteCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ByteCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
Copyright © 2019. All rights reserved.


About this Project
This project portrays the different factors of pollution in China through the Chinese social media site Weibo. Weibo is a popular microblogging forum, similar to Twitter, that allows individuals a channel for self-expression. The project aims to show the depiction of the politically sensitive topic of pollution through the use of crowdsourced social media data (via Weibo) in order to visually understand the conditions on the ground in the country and to understand the extent to which the topic of pollution is censored.
- The Data Action Project Team
Wenfei Xu, Researcher
Mike Foster, GIS/Data Visualization Specialist
Sarah Williams, Director - Civic Data Design Lab


---
layout: def
---
Two observables $A$ and $B$ are compatible if their commutator is zero. That is, $[A, B]=0$.
Notations
There seems to be no definite notation but often the commutator notation of $[A, B]=0$ is used to mean that $A$, $B$ are compatible.
Concepts
$A$ and $B$ share the same eigenstates
This follows from $A$ and $B$ sharing eigenstates if $[A, B]=0$.


Over the past several years, we have seen an explosion in the number of tools and services that enable scholars to improve their personal productivity whether it is socially enabled reference managers or cloud-hosted experimental environments. However, we have yet to see a step-change in the productivity of the system of scholarship as a whole.
While there are certainly broader social reasons for this, in this talk I argue that we are just now at a technical position to create radical change in how scholarship is performed. Specifically, I will discuss how recent advances in machine reading, developments in open data and explicit social networks, can be used to create scholarly knowledge graphs. These graphs can connect the underlying intellectual corpus with ongoing discourse allowing the development of algorithms that hypothesize, filter and reflect alongside humans.
Paul Groth is Distruptive Technology Director at Elsevier Labs. He holds a Ph.D. in Computer Science from the University of Southampton (2007) and has done research at the University of Southern California and the VU University Amsterdam.
His research focuses on dealing with large amounts of diverse contextualized knowledge with a particular focus on the web and science applications. This includes research in data provenance, data science, data integration and knowledge sharing. Paul was co-chair of the W3C Provenance Working Group that created a standard for provenance interchange.
He is co-author of Provenance: an Introduction to PROV , The Semantic Web Primer: 3rd Edition , as well as numerous academic articles. He blogs at http://thinklinks.wordpress.com. You can find him on twitter: @pgroth.
Luc Moreau and Paul Groth (2013). Provenance: An Introduction to PROV. Synthesis Lectures on the Semantic Web: Theory and Technology. Morgan & Claypool. http://dx.doi.org/10.2200/S00528ED1V01Y201308WEB007
Grigoris Antoniou, Paul Groth, Frank van Harmelen and Rinke Hoekstra (2012). A Semantic Web Primer. Third edition. Computer Science and Intelligent Systems. MIT Press. ISBN: 978-0-262-01828-9


This feature enables users to customize native template of Data loading spinner by providing their own template when data loading is in progress. for it's basic usages and example please refer Basic Usage section.
As same as the all other templates, we can bind a specific property #ngDropdownLoadingSpinner
into ng-template
to indicates customize data loading spinner is need to be applied.
The following code block example shows the way of dropdown data loading template usages. In here we used simple text to override the native loading functionality. You can provide your own custom templates with any custom styles as you want.


Disk Life
Disk Life does a 2-d pool table like simulation on
"Disk Creatures". Most of the time in this program went into the
physics simulation and not the creatures. The physics engine does a
time accurate collision model ( event model with time of collision
calculated ). The collision detection algorithm is a "sift and prune"
O(N) algorithm whereas brute force pairwise algorithms are O(N^2). The
creatures react simply by getting damaged from a collision and create a
spring connecting any two colliding disks that can break if stretched
too far. When a creature dies an energy disk is created in its place.


Reference Number:
X001150888
Contract Date:
2015-18-12
Description of Work:
1282 Computer Equipment - Servers
Contract Period:
2015-18-12 to 2016-07-01
Delivery Date:
2016-07-01
Original Contract Value:
$45,992.32
Current Contract Value:
$45,992.32
Comments:
This contract is a call-up against a Shared Services Canada procurement tool.
Former Public Servant in Receipt of a Pension under the Public Service Superannuation Act:
No


(make (delicious code)
(maplescript:compile code))
Say hello to MapleScript, a lightweight and intuitive Lisp over JavaScript.
MapleScript may not be Canadian, but it does compile to JavaScript. It can be used with any JS library and contains a built-in event system, a virtual DOM, and a JSX-like syntax for creating html, all in about 24kb of minified overhead.
Why did you make it?
The purpose behind MapleScript is to allow you to trade out 100kb+ libraries for a much smaller language that gives you the same core power natively. To illustrate, the MapleScript repository includes an ~8kb framework called Syrup that leverages this power to help you build reactive, component-based applications with a redux-like state and lifecycle events.
Installing
You can install MapleScript via npm or yarn.
npm install --save-dev maplescript
# or
yarn add maplescript --dev
You can also download MapleScript language support for Atom!
Compiling Manually
import { compile, compileCode } from 'maplescript';
compile('path/to/file.maple', (err, result) => {
if (err) throw err;
fs.writeFileSync('path/to/output.js', result);
}, {finalize: true})
// or...
const javascript = compileCode("(make x 4)", callback, {finalize: true});
Note that if the finalize
option is not set to true, you will not get the core library included in the output. This is automatically set to true for each of the provided plugins.
Webpack Loader
import maple from 'maplescript/plugins/webpack';
// ...in the config...
{
module: {
loaders: [
{ test: /\.maple$/, loader: maple() },
]
}
}
Gulp Plugin
import gulp from 'gulp';
import { log } from 'gulp-util';
import maple from 'maplescript/plugins/gulp';
gulp.task('maple', () => {
gulp.src('./src/*.maple')
.pipe(maple().on('error', log))
.pipe(gulp.dest('./public/'));
});
Browserify Plugin
import gulp from 'gulp';
import browserify from 'browserify';
import mapleify from 'maplescript/plugins/browserify';
import source from 'vinyl-source-stream'; // <- standard re-gulpification
gulp.task('maple', function () {
return browserify({entries: ['/path/to/entry.maple'], extensions: ['.maple']})
.transform(mapleify)
.bundle()
.pipe(source('app.js'))
.pipe(gulp.dest('path/to/output_directory'));
});
Language Reference
In MapleScript, all expressions return values and, aside from raw data, just about everything is syntactically structured like a function call. Function calls are just lists of values enclosed in parentheses ("s-expressions"). Here are a few MapleScript s-expressions and their JavaScript equivalents:
(foo bar baz)
-- foo(bar, baz);
(Math.round)
-- Math.round();
(if
(= x y) foo
(all (?< x y) (?> x z)) bar
baz)
---
if (x === y) {
return foo;
} else if (x < y && x > z) {
return bar;
} else {
return baz;
}
---
Comments
As you may have already noticed, single line comments are prefixed with --
while multi-line comments are surrounded by two instances of ---
, just like YAML front matter.
-- This is a single line comment.
---
This is a multi-line
comment block.
---
Declarations
In MapleScript, all named values (variables, functions, etc) are translated to const
declarations and all of these are created with the make
function.
Normally, make
takes 2 arguments — one for the variable name and one for the value:
-- A variable `foo` with a value of 'bar'.
(make foo 'bar')
However, when you're defining a function, make
takes any even number of arguments. You can think of these arguments as occurring in pairs where the first item in the pair is a pattern that describes a way the function can be called and the second item in the pair is what should be returned when that pattern is used:
-- Whenever we call `baz` of `x`,
-- we'll return the result of adding x to x.
(make (baz x) (+ x x))
You can give make
additional arguments in order to create more patterns for your function. This is discussed more in the section on functions.
Objects
MapleScript objects are just JavaScript objects. However, they are written a little differently and there is a convention of using JavaScript symbols as keys where possible. In MapleScript, the syntax for referencing a symbol is :symbol-name
.
You are allowed to use dashes in symbol names because of how they compile: Symbol.for("symbol-name")
.
Here is an example of a MapleScript object:
(make person {
:name 'John'
:eyes 'hazel'
:hair 'brown'
})
Odd numbered items are keys. Even numbered items are associated values. Of course, keys don't have to be symbols, it's just convention. When the key is a normal string key, you can access it like this: object.key
. When it's a symbol, you can access it like this: object:key
.
In fact, there is no array notation syntax for accessing values inside of objects. Here's how you'll do it:
foo.0
-- foo[0];
(m:get foo bar)
-- foo[bar];
If you need to reference this
, you can still use the keyword this
, or you can use &
. For example, &foo
, &.foo
, and &:foo
.
Regarding m:get
, m
is a reference to the MapleScript core library (which is always available) and get
retrieves values from objects and arrays.
MapleScript also takes a tip from CoffeeScript and allows you to perform "conditional lookups". For example, the expression foo?:bar?.baz
will only return the value for baz
if all the values along the chain exist. So if foo
doesn't exist or if foo:bar
doesn't exist, it will return undefined rather than throwing an error.
Operators
Most of the MapleScript operators are the same as in JavaScript except that they're written in prefix notation as function calls. There are only a couple of differences as outlined below:
(+ x y z) => x + y + z
(- x y z) => x - y - z
(* x y z) => x * y * z
(/ x y z) => x / y / z
(= x y z) => x === y === z
(!= x y z) => x !== y !== z
(% x y) => x % y
(?< x y) => x < y
(?> x y) => x > y
(<= x y) => x <= y
(>= x y) => x >= y
(not x) => !x
To help with some of this, there are a few built-in special forms for performing logic:
(all (= x y) (= a b))
=> x === y && a === b
(any (= x y) (= a b))
=> x === y || a === b
(none (= x y) (= a b))
=> !(x === y) && !(a === b)
Notice that these are called "special forms" because even though they are structured like function calls, each argument is not eagerly evaluated. This works because we transpile to infix JavaScript operators rather than to actual function calls.
MapleScript does not contain any infix or unary operations. It just has functions and function-like special forms. As such, the following JavaScript operations have been repurposed as functions in MapleScript:
-- typeof x
(m:typeof x)
-- x instanceof y
(m:instanceof x y)
-- new Foo(x, y)
(m:new Foo x y)
Conditions
The MapleScript condition is another special form. The if
expression looks like a function call but it can only work properly if we don't eagerly evaluate all of its arguments. They're conditional, after all.
But if we think of if
like a function call, arguments are divided into pairs where the first member of the pair is a condition and the second member is an expression to evaluate if the condition was truthy. If the last argument does not have a second pair member, it is used as an else case.
(make food 'pizza')
(if (= food 'pizza') (eat food))
(if
(= food 'pizza')
(eat food)
-- otherwise...
(dontEat food))
(if
(= food 'pizza') (m:log 'yum!')
(= food 'fish') (m:log 'gross')
(m:log 'never tried it'))
If you find yourself needing a visual trigger to detect that else case, one option is to use the :else
symbol. There's nothing special about it, but it is a truthy value so it'll always pass and it has clear semantic meaning.
(if
(= food 'pizza')
(eat food)
:else
(dontEat food))
Sometimes you will need to execute more than one expression if a condition is true. In that case, you can use the do
special form.
All do
really does is create a block of many expressions wrapped up in a single expression.
(if
(= food 'pizza')
(do
(eat 'food')
(m:log 'yum!')))
Iteration
Although MapleScript is loosely functional, it encourages you to write functional code. To that end, it doesn't include any new iteration syntax. You can use native methods like Array.map
or any other iterative function, or you can use recursion.
(make arr [1 2 3])
(arr.map (@ [num] (* num 10)))
=> [10, 20, 30]
(make (manyLogs num)
(do (m:log 'running')
(if (?> num 0) (manyLogs (- num 1)))))
(manyLogs 3)
=> logs "running" 3 times
Functions
Because all MapleScript expressions return a value, functions don't have return
statements. Instead, they will implicitly return the value of the last expression executed.
Functions can be named or anonymous but named functions can be polymorphic (meaning you can execute different function bodies depending on what your arguments look like).
Named functions are created using the make
command, which must take an even number of arguments. Those arguments can be thought of as occurring in pairs where the first member of the pair is a function pattern and the second member represents what is returned when that pattern is matched. In order to execute multiple commands within a function body, you'll wrap them up in a do
block.
Unnamed (anonymous) functions are created by calling the @
function. If the first argument you pass to @
is an array, its items will be used as parameters for the function. Anonymous functions may contain as many commands as necessary without the need to wrap them in a do
block.
-- A function `add` taking x and y
-- It returns the result of adding x to y.
(make (add x y) (+ x y))
-- An anonymous function with the same job.
(@ [x y] (+ x y))
-- A function with two possible patterns.
-- If we call (factorial 0), we'll return 1.
-- If we call (factorial n), we'll recurse until
-- we hit the other pattern.
(make (factorial 0) 1
(factorial n) (* n (factorial (- n 1))))
-- A function where the body executes
-- multiple commands
(make (foo x)
(do (something x)
(somethingElse x)))
-- The `do` block is not necessary for
-- anonymous functions.
(make foo (@ [x] (something x) (somethingElse x)))
Within polymorphic functions, you can add qualifiers to your parameter lists. In other words, if the arguments that come in match the pattern, you can execute an additional test before the match is proved.
-- Factorial of n where n is less than 2, return 1.
-- Factorial of n in any other case, recurse.
(make (factorial n (where (?< n 2))) 1
(factorial n) (* n (factorial (- n 1))))
Keep in mind that your patterns will be tested in the order in which they are defined.
When one of your arguments is expected to be an array, you have a few extra options for pattern matching. In the following example, we'll test for an empty array as well as destructure a populated array into variables representing the first item and a slice containing all remaining items.
-- A function for doubling each number in an array.
(make
-- With just one argument, recurse and add an accumulator.
(doubleEach arr)
(doubleEach arr [])
-- With an empty array and accumulator, return the accumulator.
(doubleEach [] accum)
accum
-- Otherwise, destructure our array into the first item and
-- a new array of all remaining items. Multiply the first item
-- by 2 and add it to the accumulator then recurse with the
-- rest of the items so we eventually hit the second pattern.
(doubleEach [first|rest] accum)
(doubleEach rest (accum.concat (* 2 first))))
(doubleEach [2 3 4])
=> [4, 6, 8]
Note that in the above function, first|rest
must not contain any spaces.
Additional argument destructuring will not happen within the argument pattern. Instead, you'll use the destr
function for it.
-- Turn object properties into variables with the same names
(make (addProps obj)
(do (destr obj [ :foo :bar ])
(+ foo bar)))
(addProps { :foo 2 :bar 3 })
=> 5
-- Turn object properties into variables with different names
(make (mltProps obj)
(do (destr obj { :foo x :bar y })
(* x y)))
(mltProps { :foo 2 :bar 3 })
=> 6
Data types
MapleScript sticks with JavaScript's native data types for the most part. However, it removes your ability to use the typeof
operator and instead provides a function called m:typeof
that will give you much better accuracy. The result of calling this function is always a symbol.
(m:typeof 'foo') => :string
(m:typeof 100) => :number
(m:typeof (@ x)) => :function
(m:typeof [1 2 3]) => :array
(m:typeof { :x 'y' }) => :object
(m:typeof null) => :null
(m:typeof undefined) => :undefined
(m:typeof NaN) => :nan
(m:typeof :foo) => :symbol
(m:typeof /foo/g) => :regexp
(m:typeof (m:new Date)) => :date
(make div (m:dom '#my-div'))
(m:typeof div) => :htmlelement
(make worker (m:new Worker 'url'))
(m:typeof worker) => :process
(make span <\span>'hello!'<\/span>)
(m:typeof span) => :vnode
The instanceof
operator has also been re-purposed as m:instanceof
, however this is just a pass-through. It doesn't do anything different or special.
Events
MapleScript has a built-in system for subscribing to and triggering events. The most important thing to keep in mind here is that all events are named by symbols.
(make (handler data)
(m:log `I got ${data}!`))
-- Subscribe to an event
(m:handle :my-event handler)
-- Trigger the event
(m:signal :my-event 'foo')
=> logs "I got foo!"
-- Unsubscribe to an event
(m:unhandle :my-event handler)
(m:signal :my-event 'bar')
=> Nothing happens
Error handling
MapleScript's technique for error handling is built on the event system and allows you to decouple your "trys" from your "catches".
The m:attempt
function takes an event channel and a function to execute. If that function throws an error, the error will be caught and signaled along the event channel.
(make (failer)
(m:attempt :bad-json (@ (JSON.parse 'asdfasdf'))))
(m:handle :bad-json (@ [err] (m:log err)))
(failer)
=> Logs the error
Imports & Exports
Importing modules in MapleScript is done with the import
function. The first argument is the location of the module. The second argument is optional and represents variables to be generated from the values in that module.
-- Import a module but don't reference any specific values
(import '/path/to/file')
-- Import a module and create a variable called `foo` as a
-- reference to the whole thing.
(import '/path/to/file' foo)
-- Assume the module exports an object with keys `foo` and `bar`.
-- Create variables called `foo` and `bar` as references to these values.
(import '/path/to/file' [foo bar])
-- Assume the module exports an object with symbol keys `:foo` and `:bar`.
-- Create variables called `foo` and `bar` as references to these values.
(import '/path/to/file' [ :foo :bar ])
-- Assume the module exports an object with keys `:foo` and `:bar`.
-- Create variables called `x` and `y` as references to these values.
(import '/path/to/file' { :foo x :bar y })
When it comes to exports, it is important to remember that all MapleScript modules export an object. No matter how you structure your export statement, the result will be an object.
-- Export an object with key `:foo` as a reference to `foo`.
(export foo)
-- Export an object with keys `:foo` and `:bar` as references
-- to values `foo` and `bar`.
(export [foo bar])
-- Export an object with keys `:foo` and `:bar` as references
-- to values `foo` and `bar`.
(export {
:foo foo
:bar bar
})
The other useful tool you can apply during export is aritization. Sometimes we may define a polymorphic function where certain "morphs" are intended just for recursive purposes. For example:
(make
(doubleEach arr)
(doubleEach arr [])
(doubleEach [] accum)
accum
(doubleEach [first|rest] accum)
(doubleEach rest (accum.concat (* 2 first))))
-- Here, we only want a user to apply the first function body
(doubleEach [1 2 3])
When we export this function, we can lock it down to one allowed "arity" (number of arguments) such that, if we try to call the function with a different number of arguments, we'll get an error. However, internally, that function can recurse with all kinds of arguments to its heart's content.
-- Use "/1" to denote that only 1 argument is allowed.
(export [doubleEach/1])
Async/Await
First and foremost, because async/await is not universal yet, you'll need to make sure you pass your compiled code through Babel or some such before trying to use it. MapleScript will translate async/await into raw ES2017 code.
Because async functions need to implement try/catch in order to properly handle rejected promises, MapleScript makes you choose an error channel for your async functions when you define them. Having done this, you can handle their errors just like you would with any other function.
(make foo
(@async :foo-error []
(await (something cool))
(await (more cool stuff))
(done)))
(handle :foo-error (@ [err] (m:log err)))
Chains
Sometimes Lisp-y syntax can make JavaScript-y things gross.  So to ease your pain in cases like this, MapleScript includes the "context chain".
A context chain is a special form that begins with ->
and evaluates each of its arguments in order, passing in the result of the previous one as the this
context for the next one.
(-> (createPromise)
(&then (@ [result] (createPromise result)))
(&then (@ [result] (createPromise result)))
(&then (@ [result] (m:log result))))
-- a jQuery example
(-> ($ '#my-div')
(&addClass 'foo')
(&hide))
Any time you start thinking you need to put more parentheses on the left-hand side of an expression, try using a context chain instead.
Less frequently, you may find yourself in need of a "call chain" which is actually a function (not a special form) that allows you to mimic something like foo()()()
in JavaScript:
(make (foo x)
(@ [y]
(@ [z]
(+ x y z))))
-- Instead of foo(2)(3)(4), we can do...
(>>= foo [2] [3] [4])
Without the call chain, you might be left having to do something like (((foo 2) 3) 4)
and nobody likes extra parentheses on the left.
For those of you who are familiar with Haskell, it may be important to call out the fact that >>=
does not denote a monad in MapleScript.
Virtual DOM
MapleScript provides a very nice way to create virtual DOM nodes (meaning an object tree representing the DOM). Virtual nodes can be rendered into real nodes or diffed against other virtual nodes to find the differences between the two virtual trees. With those differences, you can quickly make changes to an existing real DOM.
The syntax for this is inspired by React's JSX dialect, but you don't need any extra libraries to make it work. It's built in. We call it MapleML. Unlike JSX, MapleML does not use attribute={value}
syntax. Instead, you'll pass in an object containing all properties and attributes for each element — <div { :id 'my-div' }></div>
. Because this object's keys will be symbols, you do not have to modify reserved words. For example, you do not have to change class
to className
as you do in JSX. Instead, you'll use the symbol :class
.
-- Create a custom dom node called Title.
-- Custom element functions must begin with a capital letter
-- in order to be compiled correctly when written
-- with MapleML.
(make (Title attrs children)
<\h1 { :class attrs:class }>
children
<\/h1>)
-- Build a couple virtual instances of Title
(make vTitle1 <\Title { :class 'foo' }>'Hello, world!'<\/Title>)
(make vTitle2 <\Title { :class 'bar' }>'Goodbye, world!'<\/Title>)
-- Generate real dom nodes from one of our virtual titles
(make realTitle (m:vdom:render vTitle))
-- Drop our real dom nodes into the document body
(-> (m:dom 'body') (&appendChild realTitle))
-- Get the differences between our 2 virtual dom trees
(make changes (m:vdom:diff vTitle1 vTitle2))
-- Use those changes to modify the real DOM which
-- will automatically update.
(m:vdom:patchNodes realTitle changes)
Core library
MapleScript comes with a collection of built-in functions that make life a lot easier. They are all available under the global m
namespace, which is always available to you without having to import anything.
(m:apply fun args [ctx])
Calls a provided function (fun
) with argument list args
, optionally with provided context ctx
. Returns the result of the applied function.
fun
- A function to call.args
- Array. Contains all arguments to pass to the function.ctx
- Optional. A context in which to call the function.
(make (logger text)
(m:log text))
(m:apply logger ['hello, world!'])
=> logs 'hello, world!'
(m:attempt channel fun)
Calls a provided function (fun
) and checks to see if it produced any errors. If it did, catches the error and broadcasts it on a global event channel (channel
). If no errors are produced, returns the result of calling fun
.
channel
- Symbol. An event channel name.fun
- Function. Will be executed and checked for errors.
(m:handle :bad-json
(@ [err] (m:log err)))
(m:attempt :bad-json
(@ (JSON.parse 'asdfasdf')))
(m:bind fun, ctx)
Binds a function to a context and returns the new function.
fun
- Any function.ctx
- Any value. Will become thethis
context of the new function.
(make ctx 'foo')
(make (myfun)
(m:bind (@ (m:log &)) ctx))
(myfun)
-- logs 'foo'
(m:contains list value)
Determines whether a string or array (list
) contains a value.
list
- Any String or Array.value
- The value to search for in the list.
(m:contains [ :a :b :c ] :b)
=> true
(m:contains 'abc' 'b')
=> true
(m:copy collection)
Generates a deep copy of a provided value (collection
) as long as that value is an object or an array. If any other data type is provided, will return the provided value.
collection
- Object or Array. The collection to be copied.
(make obj { :foo 'bar' })
(make copy (m:copy obj))
obj:foo => 'bar'
copy:foo => 'bar'
(= foo copy) => false
(m:dangerouslyMutate key val object)
Allows you to mutate the value of a key in an existing object. This is necessary to perform certain JavaScript actions such as setting location.href
.
key
- String or Symbol. The name of the key to mutate.val
- The new value for the key.object
- The object receiving the change.
-- dangerously mutate href to foo in location
(m:dangerouslyMutate 'href' '/foo' location)
(m:die msg)
Creates and throws an error built from a provided message (msg
).
msg
- String. The error message.
(m:die 'Application broke!')
(m:dom selector)
Selects a single element from the real DOM by the provided selector.
selector
- String. A standard, CSS selector string.
(m:dom '.my-class')
=> <\div class="my-class">
(m:domArray selector)
Selects an array of elements from the real DOM by the provided selector.
selector
- String. A standard, CSS selector string.
(m:domArray '.my-class')
=> [<\div class="my-class">, <\div class="my-class">]
(m:eql obj1 obj2)
Determines whether two provided objects are deep equal. Returns a boolean.
obj1
- One of two objects to compare.obj2
- Another of two objects to compare.
(m:eql { :foo 'bar' }
{ :foo 'bar' })
=> true
(m:eql [1 2 3]
[1 2 3 4])
=> false
(m:get collection key)
Retrieves a value from a collection.
collection
- Any kind of object with retrievable values.key
- Number, String, or Symbol. Identifies the key of the value to be retrieved.
(make person { :name 'John' })
(make key :name)
(m:get person key)
=> 'John'
(m:handle channel fun)
Registers a handler function (fun
) for events broadcast on a global event channel (channel
). Returns the handler.
channel
- Symbol. The name of an event channel.fun
- The handler function. Takes the data sent over the channel.
(m:handle :my-event (@ [data] (m:log data)))
(m:signal :my-event 'foo')
=> logs 'foo'
(m:hasKey obj key)
Determines whether an object (obj
) owns a provided key.
obj
- Any Object.key
- Any String or Symbol.
(make person {
:name 'John'
:eyes 'hazel'
:hair 'brown'
})
(m:hasKey person :name)
=> true
(m:hasKey person 'prototype')
=> false
(m:head array)
Retrieves the first item in an array.
array
- Any array.
(m:head [1 2 3])
=> 1
(m:instanceof val type)
Determines whether a value (val
) was built from a constructor (type
). Returns a boolean.
val
- Any value.type
- A constructor function.
(make date (m:new Date))
(m:instanceof date Date)
=> true
(m:dom selector)
Selects a single element from the real DOM by the provided selector.
selector
- String. A standard, CSS selector string.
(m:dom '.my-class')
#=> <\div class="my-class">
(m:keys object)
Returns an array of all string and symbol keys in a provided object.
object
- The object whose keys we want to retrieve.
(make obj {
foo 1
"bar" 2
:baz 3
})
(m:keys obj)
=> ["foo", "bar", Symbol.for("baz")]
(m:last array)
Retrieves the last item in an array.
array
- Any array.
(m:last [1 2 3])
=> 3
(m:lead array)
Creates a slice of all array items except the last one.
array
- Any array.
(m:lead [1 2 3])
=> [1, 2]
(m:log ...msgs)
A pass-through to console.log. If console
does not exist in the current environment, fails silently.
...msgs
- Items to log to the console.
(m:log 'hello' 'world')
=> logs 'hello' 'world'
(m:map collection fun)
Iterates over all items in an array or object and returns a new shallow copy of that object as the result of calling a function (fun
) on each item.
collection
- Any array or plain object.fun
- A function to call for each item. Takes argumentsitem
andindex/key
.
(m:map [1 2 3] (@ [item index]
(if (= 0 (% index 2))
(* item 10))
item))
=> [1, 20, 3]
(m:map { :foo 1 :bar 2 } (@ [item key]
(if (= key :foo)
(* item 10))
item))
=> { [Symbol.for("foo")]: 10, [Symbol.for("bar")]: 2 }
(m:merge ...objects)
Takes a series of objects or arrays and merges them into a new object/array containing shallow-ly copied items from each argument.
...objects
- Arrays or objects.
(m:merge { :foo 1 } { :bar 2 })
=> { :foo 1 :bar 2 }
(m:merge [1 2] [3 4])
=> [1 2 3 4]
(m:new constructor [...args])
Instantiates a constructor.
constructor
- A function for constructing an object....args
- Optional arguments to pass to the constructor.
(m:new Date '10/21/1985')
=> Mon Oct 21 1985 00:00:00 GMT-0400 (EDT)
m:noop
You will sometimes need a function that does nothing. Here's one for you.
(m:noop)
=> nothing happens
(m:random array)
Selects a random item from an array.
array
- Any array.
(m:random [1 2 3 4 5])
=> 2
(m:random [1 2 3 4 5])
=> 5
(m:range from through)
Creates an array populated by all numbers from from
through through
.
from
- Number. The first item in the range.through
- Number. The last item in the range.
(m:range 1 10)
[1 2 3 4 5 6 7 8 9 10]
(m:remove collection key)
Returns a new, shallow copy of a collection with a provided key removed.
collection
- Object or Array. Contains an item to be removed.key
- Identifies the object key or array index to be removed.
(make obj { :foo 1 :bar 2 })
(make arr ['a' 'b' 'c'])
(m:remove obj :foo)
=> { :bar 2 }
(m:remove arr 1)
=> ['a' 'c']
(m:signal channel [data])
Broadcasts data on a global event channel. Returns undefined.
channel
- Symbol. The name of the event.data
- Optional. Data to send along with the event.
(m:handle :my-event (@ [data] (m:log data)))
(m:signal :my-event 'foo')
=> logs 'foo'
(m:tail array)
Creates a slice of all array items except the first one.
array
- Any array.
(m:tail [1 2 3])
=> [2, 3]
(m:throw err)
Throws an error object.
err
- Any error object.
(m:throw (n:new Error))
=> ERROR!
(m:typeof data)
Determines the type of data
and returns one of the following symbols:
:array, :boolean, :date, :function, :htmlelement, :nan, :null, :number, :object, :process, :regexp, :string, :symbol, :undefined, :vnode
. Provides more accurate output than JavaScript's native typeof
operator.
data
- Any value.
(m:typeof []) => :array
(m:typeof true) => :boolean
(m:typeof (m:new Date)) => :date
(m:typeof (@ null)) => :function
(m:typeof (m:dom 'div')) => :htmlelement
(m:typeof NaN) => :nan
(m:typeof null) => :null
(m:typeof 4) => :number
(m:typeof {}) => :object
(m:typeof (m:new Worker 'url')) => :process
(m:typeof /foo/g) => :regexp
(m:typeof 'foo') => :string
(m:typeof :foo) => :symbol
(m:typeof undefined) => :undefined
(m:typeof <\div><\/div>) => :vnode
(m:unhandle channel fun)
Removes a handler function from a global event channel. Returns undefined.
channel
- Symbol. The name of the event.fun
- The function to remove.
(make handler (@ [data] (m:log data)))
(m:handle :my-event handler)
(m:signal :my-event 'foo')
=> logs 'foo'
(m:unhandle :my-event handler)
(m:signal :my-event 'foo')
=> nothing happens
(m:update collection key val)
Returns a new, shallow copy of a collection with a provided key updated with a new value.
collection
- Object or Array. Contains an item to be updated.key
- Identifies the object key or array index to be updated.val
- The new value for the key.
(make obj { :foo 1 :bar 2 })
(make arr ['a' 'b' 'c'])
(m:update obj :foo 3)
=> { :foo 3 :bar 2 }
(m:update arr 1 'd')
=> ['a' 'd' 'c']
(m:vdom:create type [attrs] [children])
Creates a new virtual DOM node. MapleML syntax is a shortcut for this function.
type
- String. The type of node to create.attrs
- Optional. An object specifying all attributes. Each should be named with a symbol.children
- Optional. An array of child virtual DOM nodes.
(m:vdom:create 'div' { :class 'my-class' } [
(m:vdom:create 'span' {} ['Hello, world!'])
])
-- produces the same thing as...
<\div { :class 'my-class' }>
<\span>
'Hello, world!'
<\/span>
<\/div>
-- which is a virtual tree
(m:vdom:diff vtree1 vtree2)
Compares two virtual trees and outputs the differences between them.
vtree1
- VNode. The result of callingm:vdom:create
.vtree2
- Another VNode.
(make tree1 <\div>'hello'<\/div>)
(make tree2 <\div>'goodbye'<\/div>)
(m:vdom:diff tree1 tree2)
=> Object of differences
(m:vdom:render vtree)
Converts a virtual DOM tree into a tree of real DOM nodes.
vtree
- VNode. The result of callingm:vdom:create
.
(make tree1 <\div>'hello'<\/div>)
(make tree2 <\div>'goodbye'<\/div>)
(m:vdom:render <\div { :class 'foo' }>'hello'<\/div>)
=> <\div class="foo">hello<\/div>
(m:vdom:injectNodes nodes target)
Injects a tree of nodes into the real DOM. Returns the tree of real nodes.
nodes
- VNode or HtmlElement.target
- String or HtmlElement.
(m:vdom:injectNodes <\div { :class 'foo' }>'hello'<\/div> '#app')
-- Injects real nodes into the selement identified by '#app'.
-- Returns <\div class="foo">hello<\/div>
(m:vdom:patchNodes realNodes changes)
Updates a tree of real DOM nodes according to an object of virtual DOM changes.
realNodes
- HtmlElement.changes
- Object. The result of callingm:vdom:diff
on two virtual trees.
(m:warn ...msgs)
A pass-through to console.warn. If console
does not exist in the current environment, fails silently.
...msgs
- Items to log to the console.
(m:warn 'Scary warning!')
-- logs 'Scary warning!'
Syrup
Syrup is a simple framework built using MapleScript's virtual DOM technology to provide a somewhat React/Redux-like experience. With it, you can build components and tie them to a state object. When the state object changes, your app can re-render itself based on those changes. Here is a simple example:
(import 'maplescript/syrup/syrup' syrup)
-- Start by defining initial state values
(make initialStateValues { :title-text 'App is alive!' })
-- Create a function for transforming the state
(make (reducer state action)
(m:merge state { :title-text action:title-text }))
-- Use the above values to create an application state
-- The :my-app symbol denotes an event channel
-- The state will receive its updates on that channel
(make state (-> (syrup:state :my-app initialStateValues)
(syrup:reduce & reducer)))
--- Now we'll create a nested component architecture ---
-- Define a basic Title element
(make (TitleBase attrs)
<\h1>attrs:title-text<\/h1>
)
-- Now extend that element with lifecycle events
(make Title (-> (syrup:afterMount TitleBase (@ (m:log 'aftermount')))
(syrup:beforeUnmount & (@ (m:log 'beforeunmount')))))
-- Define our top-level application element
-- It will create an instance of Title
(make (App attrs)
<\div { :class 'app' }>
<\Title { :title-text attrs:state:title-text } />
<\/div>
)
-- Render our app (with state!) into the DOM
(syrup:render App state '#app')
--- Now we'll modify the state and trigger an auto-rerender ---
-- Send data on the event channel associated with the state
(m:signal :my-app { :title-text 'App is reactive!' })
-- The app automatically re-renders using the new text.


{% load static %}
App Upload Page
Android
iOS
Upload Android App
{% csrf_token %}
PRODUCT
{% for product in products %}
{{ product }}
{% endfor %}
FILE
iOS
{% csrf_token %}
PRODUCT
{% for product in products %}
{{ product }}
{% endfor %}
BUNDLE ID
FILE
<< Download
Settings >>


Homes are hand-picked and furnished. Each comes with amenities like fast WiFi, grocery delivery, and more to guarantee the highest quality stay-experience.
We handle employee booking so you don't have to. Reserving time at the home is as easy as pushing a button.
Homes are professionally cleaned in between each stay and CDC-compliant to ensure safety during these times. In addition, we provide 24/7 contactless service in case anything is needed.
Renting a shared vacation home is far cheaper than providing a stipend for each employee.
Homes are cleaned and CDC-compliant to keep your employees safe during these times.
Homes are pre-vetted and furnished to guarantee a comfortable and relaxing experience.
Homes are selected to be within driving distance of your employees.
Get fast WiFi, quality monitors, ergonomic chairs, an adjustable desk, and anything else needed in case employees want to work.
Your employees will get groceries on arrival, local recommendations, 24/7 contactless support, and more.


Listening to the Past: An African-American Lullaby
My research tries to capture the sounds of the past before the advent of recorded music. I’m curious about ideas that were spoken and sung and shouted and strummed, focusing particularly on musical sounds produced by Afro-Atlantic people in the long eighteenth century. A few of these sounds were transcribed into dots and lines on paper. The descendants of others survive in thriving contemporary music genres. These imprints contain clues about the sounds that weren’t so lucky.
The musical expression of early musicians has not been entirely lost; much of it has been preserved or resurrected in a variety of print and performance-based archives that are available for study. In my work, I question the primacy of documents in the pursuit of knowledge about the sonic past and show that our conventional modes of study can make it difficult to explore aural culture through textual records.
In what follows I share an experimental encounter with a particular song that found its way before my eyes and into my ears. It is not the perfect object through which to answer my questions about the musical life of Afro-descendant people in the Americas, but this little lullaby taught me something about how to hear the past.
“Jungle Mammy Song”—a cringe-worthy title if ever there was one. The transcription provided by Carl Sandburg in his collection of folk music, American Songbag (1927) explains:
Margaret Johnson of Augusta, Georgia, heard her mother sing this, year on year, as the mother had learned it from singing, year on year, of a negro woman who comforted children with it. The source of its language may be French, Creole, Cherokee, or mixed. The syllables are easy for singing; so is the tune. It may be, as provisionally titled, a Jungle Mammy Song, in the sense that all mothers are primitive and earthly even though civilized and celestial.
The compiler, though most famous for his work as a poet and a biographer of Abraham Lincoln, was a musician and avid song-collector. His American Songbag was published during an era in which fascinations with blackface minstrelsy and “coon songs” were giving way to more folkloric presentations of American musical forms. The book offers arrangements of many different kinds of music, including cowboy songs, work songs from railroads and logging camps, and a sizable number of pieces emanating from the black experience.
In the volume, Sandburg’s appreciation of African-American music competes with his choice to refurbish long-standing stereotypes about “mammies” and render song lyrics in “negro dialect.” The Songbag is no outlier in this regard. It has long been common for white authors to denigrate and laud black music culture in the same breath. Many of the earliest accounts of Afro-Atlantic musical practices include this type of reckless and self-important ambivalence.
Both during slavery and after, the power structures of American society confined many black women to the role of caretakers of white families—creating a legacy of close yet troubled relations between black nurses and white children. In addition to the “mammy” stereotype, this arrangement has long been romanticized and idealized in literature and images emerging from white perspectives, particularly in the South. But rather than focusing strictly on the ways in which the image of the “negro woman” who sang this tune was degraded in Sandburg’s introduction and attending cultural norms, I want to ask whether this imperfect, highly mediated artifact bears witness to her experience, history, and voice. If we can mute the iconography of The Black Mammy, what might we hear?
Because we do not know much about the woman who is said to have comforted children with this song, it is difficult to imagine the contours of her life, much less the timbre of her voice. We are left to wonder many things like, did she work as a nurse and if so, how did she feel about her job? Did she sing this song to her own children? What other musical practices did she participate in? As a researcher, I would love to verify that the song was originally authored or transmitted by a newly enslaved person or from an established slave culture, since both scenarios would strengthen the song’s ties to early Afro-diasporic musical practices. Whatever the case may be, the musical transcription is a rare artifact because it connects listeners to the artistry of a female singer whose musical expression would otherwise be lost to us.
Though little is clear about the vocalist’s biography, we do know something about the way her song was circulated. She is said to have “comforted children” with it and Margaret Johnson’s mother appears to have done the same, transmitting the piece across at least three generations as it was sung “year on year.”
I am curious about why the music made such a strong impression on those who encountered it. Perhaps the original singer had an especially beautiful voice or an especially beautiful way with children. Maybe she sang it passionately to honor the memory of a particular child who had loved the piece—a first born or a dear younger sister. Or alternatively, perhaps she invented the song to shush fussy white children with a supposedly “authentic negro” lullaby as a kind of joke or a subtle act of resistance. Or the tune could have entered Sandburg’s Songbag simply because it is catchy and easy to remember.
Whatever the original inspirations for the melody might have been, the history of its circulation is a testimony to its resonance with listeners. It endures, year on year.
The song is so resonant, in fact, that it found its way from Sandburg’s page into my voice—and from there, into the voices of a new generation. When I first thumbed my way through the facsimile of American Songbag that my mother had ordered for me over the Internet on a whim, “Jungle Mammy Song” immediately caught my eye. At first disgusted by the title, I was then intrigued by the headnote and even more so by the undecipherable lyrics. I wanted to learn it so that I could hear it, hoping that it would yield some sonic information about the early music cultures I study. I also wondered if the music-making would be able to drown out Sandburg’s disrespectful story-telling.
Learning the song was a process of creation as well as discovery. At first using a mandolin to pluck out the notes, I learned the melody and finally the words—an interesting task because the unfamiliar language required a lot of guesswork. In addition to selecting a key, note values, and time-signature, the arranger took it upon themselves to punctuate the words in the same way that they would familiar syntax. Lyrics are often accompanied by dashes and commas that indicate the manner in which they should be expressed musically.
It seems bizarre to do this to an unknown language, but the directions helped me to deliver word-strings as musical phrases. The arranger probably followed the musical line when deciding how to punctuate the lyrics, rather than the other way around. Here is a recording of one of my early attempts to render the song:
The author shares an early attempt to render the lullaby.
I immediately enjoyed singing the melody and especially the expressive first words, “Ah yah.” The relaxed, open syllables and the descending notes feel quite a bit like sighing. Though I love the way the song feels in my voice, I am not entirely taken with my musical interpretation. In the recording you will notice that my vocal style is informed by classical singing and that I use a vibrato and a clear “attack” in my pronunciation. By that I mean that the syllables are not obscured by elision and the initial parts of words and notes are articulated more forcefully than they might be in other traditions.
When I learn music by reading, I find it difficult not to perform in the conventions of my classical training; much as a long-dormant accent emerges when I go home to my native East Texas. Context is everything. By contrast, in my activities as a bluegrass fiddler, I learn primarily by ear. Bluegrass is one of many music traditions that prides itself on a dependence on aural transmission. When I learn a fiddle tune, or a vocal melody by ear, I find it much easier to be expressive in my initial interpretations. To be sure, many classically trained musicians have a deft facility with sheet music and can perform it with far greater flexibility.
I bring up issues of acquisition and style because they are uniquely challenging when singing (or transcribing) for historical purposes. Because I study an early oral music culture in which there are very few transcriptions and no audio-recordings, I am interested in gleaning whatever information I can from sources that might otherwise seem only distantly connected to earlier centuries. It is so rare to find an example of women’s music from this period, and I wanted to do this song and its original performer justice. But I felt inhibited by my performance style and frustrated that I would never be able to really know how the woman who popularized this song would have sung it. Because my interest is in vernacular music and its aural circulation, it felt odd to encounter the piece through a textual transcription.
I decided to enlist some help. What if I shared the song with someone else so that I could hear it outside of my own voice? How might that open up possibilities for interpreting the piece? I teach a singing class to young women between the ages of seven and fourteen at a non-profit children’s theatre. Every once in a while I throw a strange tune at the students and let them in on my research. I explained that the song was a lullaby. It was originally sung by an African-American woman in Georgia, probably just after the era of slavery and it had been passed from woman to child. Though some of the students in my class read music, we learn by ear. I handed out copies of the song made directly from the book, but without the title or headnote.

Before learning to sing it, we talked about what the words might mean. They laughed hard at “poot a way” … and not just because it sounds like a reference to flatulence, but because several of the young women are native Spanish speakers and one of the syllable combinations sounds like a particularly bad curse word in that language. The girls were fixated on “bam, boo” possibly meaning something about bamboo trees and a forest. We all decided that “Wah me” sounds like “Why me?”
Though it was impossible to locate a fixed meaning, thinking through the possibilities allowed us to imagine certain emotional scenarios that would help us musically express the song. My students ended up interpreting the piece much as I had, but they added their own touches.
The students sing the lullaby.
We made this recording soon after learning the song. At first, I hesitated to share it because the singers don’t perform particularly well. However, I think that some of what we might hear as ‘errors’ in terms of technique open up possibilities for new interpretations and can teach us quite a bit about the process of oral circulation. In the recording, the young singers are more playful with pitch than I am and because I have no verification that Sandburg’s transcription is accurate by any means, it’s fun to imagine that by failing to execute the lyrics or music perfectly, they may not be any more ‘incorrect’ than his version.
After all, wouldn’t a song like this have changed from woman to child, from day to day, from generation to generation? I love the way the girls’ pitch slides throughout the piece, as if their voices are determined to find a more comfortable key. They reach unison on certain notes and stray and wander on others.
This rough performance exemplifies music as a process: how a single piece of music can evolve as it circulates across voices and time. It is, in a way, a sonic illustration of musical variation, helping us to perceive how a tune can exist in various forms and still be considered a single entity. Also, by encountering the song through a multi-vocal recording, we can lift it off the page and back into the realm of the vernacular. Though I don’t wish to overstate the distinction between the two modes or to romanticize the one over the other, my point is that the media through which we encounter music makes a strong impression on our understanding of it. Because I am interested in exploring vernacular music cultures historically, restoring transcriptions to aural performances is a useful way to de-privilege print and text in our efforts to hear the past.
Here is an example of one of the students, Nadia, performing the piece solo.
Nadia sings the lullaby solo.
By sharing the lullaby with a new generation of singers, I have been able to experience the song as far outside its textual representation as I can as a historical observer. Margaret Johnson’s story, Sandburg’s title and narration, and the transcription into sheet music all threatened to overpower the possibility that the song could speak its own history. Though I wanted to listen to the woman who initiated the chain of transmission that brought the piece to me, I continued to be distracted by the writing that accompanied it.
I felt persuaded that the song was a lullaby, for example, and because I myself shared the piece with children, I wanted to interpret the music and my encounter with it as something connected to childcare and a genre of music-making predominated by women. Maybe one can’t press a mute button on stereotypes. Now, having written this essay, I realize that by listening to the sounds themselves in the form of my students’ performances, I learned more than I anticipated about the nature of aural transmission and music transcription.
But what of the singer whose story I longed to uncover?
Though she remains distant and opaque to me, hidden among the silences of history and the words framing her performance in the book, her music is frequently in my ears and on my mind. It may be that knowing her song means simply that, to know it. Listening is often understood as a means to receive rather than perceive information. (“I hear you” and “I’m listening” come across a bit differently than “I see what you mean.”) By staging opportunities to listen to historical performances, we can mobilize both our fields of perception and reception. Emphasizing auditory culture also helps us to engage with historical actors who did not author their own narratives in print as subjects rather than as simple objects of history. The song, then, is not a portal into an understanding of a particular woman’s story, but an opportunity to witness something that her voice made known. Rather than repackaging the music and its creator like Sandburg did, this time, I’d rather just listen.
I wish to thank the young women in my singing class for sharing their voices with me and for challenging my assumptions. I dedicate this essay to them and to the memory of the woman who first sang this song.
The author would like to acknowledge Whitney Trettien, Darren Mueller, Ben Breen, and the Appendix editorial team for their insightful contributions to this essay.


--- layout: code title: "Code" h1: "Code" description: "say less, do more!" header-img: "./asset/image/code/code-bg-001.jpg" ---


[§46-65.6] Thomas Square; to be maintained. Thomas Square shall be maintained as a public park. [L 1925, JR 1; RL 1935, §2369; RL 1945, §6139; RL 1955, §142-25; HRS §70-121; ren and am L 1988, c 263, pt of §8]


SRCCON is built around two days of peer-led conversations, hands-on workshops, and skillshares. The community members who step up to facilitate these sessions make it all possible.
After receiving 149 session proposals, we have accepted a list of amazing sessions for this year. We’ll be working these into a final schedule which will be published in July.
There are a lot of ways to think about sessions at SRCCON, but the main thing is to consider how it’s different than other conferences you may have attended. SRCCON is highly participatory: sessions are not a panel on a stage of a speaker running through slides. This is an opportunity to compare notes, share skills, and learn from each other.
So you can be prepared to pitch a great session at SRCCON, we asked a couple previous participants to talk about their experience hosting SRCCON sessions:
Successful sessions often emerge from a single question or problem—if you’ve been struggling with just about any aspect of your work, you can bet others have dealt with it, too. (When we receive multiple pitches on the same subject, we sometimes suggest that the proposers consider combining forces, but no one’s obligated to do so.)
Last year’s sessions dealt with topics including burnout, chatbots, community-building, documentation, hiring processes, illustration, machine learning, mobile development, newsroom analytics, and user-centered design. To give you a taste, here’s a small selection of great sessions from 2016.
SRCCON is a genuinely participatory event, and it’s hard to participate in a session that’s mostly lecture with a few minutes for discussion, so we look for pitches that include real interactivity. Outstanding sessions in previous years have included design exercises, games, skillshares, small-group breakouts, physical movement, and field trips, and we’re always interested in new ideas.
It’s also useful to think about your target session length and information/activity density. Over-programming a session with too many activities can make it impossible to get to your desired end-state—but a session that’s under-designed can easily turn into a conversation between a handful of the loudest people. We’re happy to help facilitators figure out the right balance, and don’t expect perfection at the pitch stage, but it’s good to start thinking about length and density early on.
Effective SRCCON facilitation is about effort and preparation more than expertise. Our faciliators plan and guide sessions, ask great questions, share what they know, and learn from their peers. We find that the best sessions are often led by facilitators who:
On the flip side, facilitators who have a harder time have usually tried to fit too much stuff into too little time, or are underprepared for guiding an active conversation.
If that sounds like a lot of effort…it is! But it also means that people who are brand-new to the community—or to a topic—can make excellent facilitators if they’re willing to put in a little prep time. We provide group and one-on-one support to help facilitators prepare for their sessions, and we can help match you with a co-facilitator if you’re pitching solo and want someone to work with you on the ground.


I2C
I2C (pronounced eye-squared-sea, or eye-two-sea) was originally developed by Phillips to allow multiple chipsets to communicate on a 2-wire bus in home consumer devices. It has a master and one or more slaves sharing the same data bus. Instead of selecting the slaves using a digital pin like SPI (consuming an additional I/O pin), I2C uses an addressing mechanism to communicate to the selected device.
Before data is transferred, the master sends out a 7-bit address address of the slave device it wants to communicate with. It also sends one bit indicating whether it wants to send data to the device or receive data from the device. When a slave sees its address on the bus, it will acknowledge its presence. At this point, the master can send or receive data. The master will start data transfers with a "start" condition before it sends any address or data and then end it with "stop" condition.
The I2C uses two wires to communicate between the I2C Master and the I2C device. These two wires are known as the SDA and SCL lines. SDA stands for Serial Data, and SCL is Serial Clock.
The I2C NETMF driver is based on transactions. If we want to read from a register on a sensor, we would first need to send it the register number we wish to read from, and then we need to read the register. Those are two transactions; a write followed by a read.
Addressing
One very important point about I2C is that I2C devices have a 7-bit address, but 8-bits are sent on the wire in the "control byte" when communicating with the I2C bus. The 8th bit tells the device whether the operation will be a read operation (the 8th bit is a 1) or a write operation (the 8th bit is a 0). When discussing I2C you should always make sure you are clear about the 7-bit address that your device uses, rather than stating your 8-bit read or write address.
Software I2C
When using I2C, it is highly recommended that you use the built-in hardware support for I2C. In some cases though it may be necessary to have another I2C bus or it is necessary to use specific pins that are not I2C pins. In this case, I2C can be handled completely in software, though performance will be lower.
The GHI libraries include a software I2C implementation in the GHI.Hardware assembly (GHI.IO.SoftwareI2CBus).
An I2C Example
This example will read the value of the register on an I2C device with the 7-bit address of 0x38. As discussed above, you first have to write the register number you want to read, two in this case, and then read the value back.
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
public class Program
{
public static void Main()
{
//create I2C object
//note that the netmf i2cdevice configuration requires a 7-bit address! It set the 8th R/W bit automatically.
I2CDevice.Configuration con =
new I2CDevice.Configuration(0x38, 400);
I2CDevice MyI2C = new I2CDevice(con);
// Create transactions
// We need 2 in this example, we are reading from the device
// First transaction is writing the "read command"
// Second transaction is reading the data
I2CDevice.I2CTransaction[] xActions =
new I2CDevice.I2CTransaction[2];
// create write buffer (we need one byte)
byte[] RegisterNum = new byte[1] { 2 };
xActions[0] = I2CDevice.CreateWriteTransaction(RegisterNum);
// create read buffer to read the register
byte[] RegisterValue = new byte[1];
xActions[1] = I2CDevice.CreateReadTransaction(RegisterValue);
// Now we access the I2C bus using a timeout of one second
// if the execute command returns zero, the transaction failed (this
// is a good check to make sure that you are communicating with the device correctly
// and don�t have a wiring issue or other problem with the I2C device)
if (MyI2C.Execute(xActions, 1000) == 0)
{
Debug.Print("Failed to perform I2C transaction");
}
else
{
Debug.Print("Register value: " + RegisterValue[0].ToString());
}
}
}
Multiple Devices
The I2C object on NETMF is a representation of the "bus" and not the "device" so you can't construct multiple I2C objects. To access multiple I2C devices you need to have multiple configurations and then when accessing device "A" we need to use configuration "A" and when accessing device "B" we need to use configuration "B".
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
public class Program
{
public static void Main()
{
//create I2C Device object representing both devices on our bus
I2CDevice.Configuration conDeviceA =
new I2CDevice.Configuration(0x38, 400);
I2CDevice.Configuration conDeviceB =
new I2CDevice.Configuration(0x48, 400);
//create I2C Bus object using one of the devices on the bus
I2CDevice MyI2C = new I2CDevice(conDeviceA);
// Note you could have chosen to create the bus using the conDeviceB parameter, which ever you choose it will be the "selected" device on the bus to start with. Here's how you would do that:
// I2CDevice MyI2C = new I2CDevice(conDeviceB);
//create transactions (we need 2 in this example)
I2CDevice.I2CTransaction[] xActions =
new I2CDevice.I2CTransaction[2];
// create write buffer (we need one byte)
byte[] RegisterNum = new byte[1] { 2 };
xActions[0] = I2CDevice.CreateWriteTransaction(RegisterNum);
// create read buffer to read the register
byte[] RegisterValue = new byte[1];
xActions[1] = I2CDevice.CreateReadTransaction(RegisterValue);
// Explicitly set the I2C bus to access device A by setting the I2C Config to the Device A's config.
MyI2C.Config = conDeviceA;
if (MyI2C.Execute(xActions, 1000) == 0)
{
Debug.Print("Failed to perform I2C transaction");
}
else
{
Debug.Print("Register value: " + RegisterValue[0].ToString());
}
// Explicitly set the I2C bus to access device B by setting the I2C Config to the Device B's config.
MyI2C.Config = conDeviceB;
if (MyI2C.Execute(xActions, 1000) == 0)
{
Debug.Print("Failed to perform I2C transaction");
}
else
{
Debug.Print("Register value: " + RegisterValue[0].ToString());
}
}
}


Toggle navigation
Data Vizualization Project
Map Interaction
Top 25 Airports Traffic 2000 - 2008
Flights Years Details per Year
Built by
Andres Guijarro


camera GALLERY 27
>>
photo_camera DCMI8
file_download DOWNLOADED PICTURES8
widgets PROJECTS PHOTOS4
photo WALLPAPERS7