scalding

Type Members

1. sealed abstract class AccessMode extends AnyRef

2. class BufferOp[I, T, X] extends BaseOperation[Any] with Buffer[Any] with ScaldingPrepare[Any]

3. abstract class CascadeJob extends Job

4. class CascadeTest extends JobTest

5. trait CascadingLocal extends Mode

6. trait CaseClassPackers extends LowPriorityTuplePackers

7. class CoGroupBuilder extends GroupBuilder

   Builder classes used internally to implement coGroups (joins).

8. class CollectFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

9. case class Csv(p: String, separator: String = ",", fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false, quote: String = "\"", sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

   Csv value source separated by commas and quotes wrapping all fields

10. trait DefaultDateRangeJob extends Job

    Sets up an implicit dateRange to use in your sources and an implicit timezone.

11. trait DelimitedScheme extends SchemedSource

    Mix this in for delimited schemes such as TSV or one-separated values By default, TSV is given

12. sealed trait Field[T] extends Serializable

13. trait FieldConversions extends LowPriorityFieldConversions

14. abstract class FileSource extends SchemedSource with LocalSourceOverride

    This is a base class for File-based sources

15. class FilterFunction[T] extends BaseOperation[Any] with Filter[Any] with ScaldingPrepare[Any]

16. abstract class FixedPathSource extends FileSource

17. class FlatMapFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

18. case class FlowState(sourceMap: Map[String, (Source, Pipe)] = ...) extends Product with Serializable

    Immutable state that we attach to the Flow using the FlowStateMap

19. class FoldAggregator[T, X] extends BaseOperation[X] with Aggregator[X] with ScaldingPrepare[X]

20. abstract class FoldFunctor[X] extends Functor

    This handles the mapReduceMap work on the map-side of the operation.

21. trait FoldOperations[+Self <: FoldOperations[Self]] extends ReduceOperations[Self] with Sortable[Self]

    Implements reductions on top of a simple abstraction for the Fields-API We use the f-bounded polymorphism trick to return the type called Self in each operation.

22. trait GeneratedTupleAdders extends AnyRef

23. trait GeneratedTupleConverters extends LowPriorityTupleConverters

24. trait GeneratedTupleSetters extends LowPriorityTupleSetters

25. class GroupBuilder extends FoldOperations[GroupBuilder] with StreamOperations[GroupBuilder]

    This controls the sequence of reductions that happen inside a particular grouping operation.

26. type Grouped[K, +V] = scalding.typed.Grouped[K, V]

27. trait HadoopMode extends Mode

28. case class HadoopTest(conf: Configuration, buffers: (Source) ⇒ Option[Buffer[Tuple]]) extends HadoopMode with TestMode with Product with Serializable

29. case class Hdfs(strict: Boolean, conf: Configuration) extends HadoopMode with Product with Serializable

30. case class IntField[T](id: Integer)(implicit ord: Ordering[T], mf: Option[Manifest[T]]) extends Field[T] with Product with Serializable

    Annotations

    @DefaultSerializer()

31. class IntegralComparator extends Comparator[AnyRef] with Hasher[AnyRef] with Serializable

32. class InvalidJoinModeException extends Exception

33. class InvalidSourceException extends RuntimeException

    thrown when validateTaps fails

34. case class IterableSource[+T](iter: Iterable[T], inFields: Fields = cascading.tuple.Fields.NONE)(implicit set: TupleSetter[T], conv: TupleConverter[T]) extends Source with Mappable[T] with Product with Serializable

    Allows working with an iterable object defined in the job (on the submitter) to be used within a Job as you would a Pipe/RichPipe

35. class Job extends FieldConversions with Serializable

    Job is a convenience class to make using Scalding easier.

36. case class JobStats(toMap: Map[String, Any]) extends Product with Serializable

37. class JobTest extends AnyRef

    This class is used to construct unit tests for scalding jobs.

38. trait JoinAlgorithms extends AnyRef

39. sealed abstract class JoinMode extends AnyRef

40. type KeyedList[K, +V] = scalding.typed.KeyedList[K, V]

41. case class Local(strictSources: Boolean) extends CascadingLocal with Product with Serializable

42. trait LocalSourceOverride extends SchemedSource

    A trait which provides a method to create a local tap.

43. trait LocalTapSource extends SchemedSource with LocalSourceOverride

    Use this class to add support for Cascading local mode via the Hadoop tap.

44. trait LowPriorityFieldConversions extends AnyRef

45. trait LowPriorityTupleConverters extends Serializable

46. trait LowPriorityTupleGetter extends Serializable

47. trait LowPriorityTuplePackers extends Serializable

48. trait LowPriorityTupleSetters extends Serializable

49. trait LowPriorityTupleUnpackers extends AnyRef

50. class MRMAggregator[T, X, U] extends BaseOperation[Tuple] with Aggregator[Tuple] with ScaldingPrepare[Tuple]

51. class MRMBy[T, X, U] extends AggregateBy

    MapReduceMapBy Class

52. class MRMFunctor[T, X] extends FoldFunctor[X]

    This handles the mapReduceMap work on the map-side of the operation.

53. class MapFunction[S, T] extends BaseOperation[Any] with Function[Any] with ScaldingPrepare[Any]

54. trait Mappable[+T] extends Source with TypedSource[T]

    Usually as soon as we open a source, we read and do some mapping operation on a single column or set of columns.

55. trait Mappable1[A] extends Source with Mappable[(A)]

56. trait Mappable10[A, B, C, D, E, F, G, H, I, J] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J)]

57. trait Mappable11[A, B, C, D, E, F, G, H, I, J, K] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K)]

58. trait Mappable12[A, B, C, D, E, F, G, H, I, J, K, L] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L)]

59. trait Mappable13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

60. trait Mappable14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

61. trait Mappable15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

62. trait Mappable16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

63. trait Mappable17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

64. trait Mappable18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

65. trait Mappable19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

66. trait Mappable2[A, B] extends Source with Mappable[(A, B)]

67. trait Mappable20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

68. trait Mappable21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

69. trait Mappable22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends Source with Mappable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

70. trait Mappable3[A, B, C] extends Source with Mappable[(A, B, C)]

71. trait Mappable4[A, B, C, D] extends Source with Mappable[(A, B, C, D)]

72. trait Mappable5[A, B, C, D, E] extends Source with Mappable[(A, B, C, D, E)]

73. trait Mappable6[A, B, C, D, E, F] extends Source with Mappable[(A, B, C, D, E, F)]

74. trait Mappable7[A, B, C, D, E, F, G] extends Source with Mappable[(A, B, C, D, E, F, G)]

75. trait Mappable8[A, B, C, D, E, F, G, H] extends Source with Mappable[(A, B, C, D, E, F, G, H)]

76. trait Mappable9[A, B, C, D, E, F, G, H, I] extends Source with Mappable[(A, B, C, D, E, F, G, H, I)]

77. class MapsideReduce[V] extends BaseOperation[SummingCache[Tuple, V]] with Function[SummingCache[Tuple, V]] with ScaldingPrepare[SummingCache[Tuple, V]]

    An implementation of map-side combining which is appropriate for associative and commutative functions If a cacheSize is given, it is used, else we query the config for cascading.

78. class MemoryTap[In, Out] extends Tap[Properties, In, Out]

79. class MemoryTupleEntryCollector extends TupleEntryCollector

80. trait Mode extends Serializable

81. abstract class MostRecentGoodSource extends TimePathedSource

82. case class MultipleDelimitedFiles(f: Fields, separator: String, quote: String, skipHeader: Boolean, writeHeader: Boolean, p: String*) extends FixedPathSource with DelimitedScheme with Product with Serializable

    Delimited files source allowing to override separator and quotation characters and header configuration

83. case class MultipleSequenceFiles(p: String*) extends FixedPathSource with SequenceFileScheme with LocalTapSource with Product with Serializable

84. case class MultipleTextLineFiles(p: String*) extends FixedPathSource with TextLineScheme with Product with Serializable

85. case class MultipleTsvFiles(p: Seq[String], fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false) extends FixedPathSource with DelimitedScheme with Product with Serializable

    Allows the use of multiple Tsv input paths.

86. case class MultipleWritableSequenceFiles[K <: Writable, V <: Writable](p: Seq[String], f: Fields)(implicit evidence$7: Manifest[K], evidence$8: Manifest[V]) extends FixedPathSource with WritableSequenceFileScheme with LocalTapSource with TypedSource[(K, V)] with Product with Serializable

    This is only a TypedSource as sinking into multiple directories is not well defined

87. class NamedPoolThreadFactory extends ThreadFactory

88. class NullTap[Config, Input, Output, SourceContext, SinkContext] extends SinkTap[Config, Output]

    A tap that output nothing.

89. class OrderedConstructorConverter[T] extends TupleConverter[T]

90. class OrderedTuplePacker[T] extends TuplePacker[T]

    This just blindly uses the first public constructor with the same arity as the fields size

91. case class Osv(p: String, f: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

    One separated value (commonly used by Pig)

92. case class PipeDebug(output: Output = ..., prefix: String = null, printFieldsEvery: Option[Int] = scala.None, printTuplesEvery: Int = 1) extends Product with Serializable

    This is a builder for Cascading's Debug object.

93. trait ReduceOperations[+Self <: ReduceOperations[Self]] extends Serializable

    Implements reductions on top of a simple abstraction for the Fields-API This is for associative and commutive operations (particularly Monoids and Semigroups play a big role here)

94. class ReflectionSetter[T] extends TupleSetter[T]

95. class ReflectionTupleConverter[T] extends TupleConverter[T]

96. class ReflectionTuplePacker[T] extends TuplePacker[T]

    Packs a tuple into any object with set methods, e.

97. class ReflectionTupleUnpacker[T] extends TupleUnpacker[T]

98. case class RichFields(toFieldList: List[Field[_]]) extends Fields with Product with Serializable

99. class RichPathFilter extends AnyRef

100. class RichPipe extends Serializable with JoinAlgorithms

     This is an enrichment-pattern class for cascading.

101. class SampleWithReplacement extends BaseOperation[Poisson] with Function[Poisson] with ScaldingPrepare[Poisson]

102. class ScaldingMultiSourceTap extends MultiSourceTap[Tap[JobConf, RecordReader[_, _], OutputCollector[_, _]], JobConf, RecordReader[_, _]]

103. trait ScaldingPrepare[C] extends Operation[C]

104. class ScanLeftIterator[T, U] extends Iterator[U] with Serializable

     Scala 2.

105. abstract class SchemedSource extends Source

     A base class for sources that take a scheme trait.

106. class ScriptJob extends Job

107. case class SequenceFile(p: String, f: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with SequenceFileScheme with LocalTapSource with Product with Serializable

108. trait SequenceFileScheme extends SchemedSource

109. abstract class SideEffectBaseOperation[C] extends BaseOperation[C] with ScaldingPrepare[C]

110. class SideEffectBufferOp[I, T, C, X] extends SideEffectBaseOperation[C] with Buffer[C]

111. class SideEffectFlatMapFunction[S, C, T] extends SideEffectBaseOperation[C] with Function[C]

112. class SideEffectMapFunction[S, C, T] extends SideEffectBaseOperation[C] with Function[C]

113. trait SingleMappable[T] extends Source with Mappable[T]

     Mappable extension that defines the proper converter implementation for a Mappable with a single item.

114. sealed abstract class SkewReplication extends AnyRef

     Represents a strategy for replicating rows when performing skewed joins.

115. case class SkewReplicationA(replicationFactor: Int = 1) extends SkewReplication with Product with Serializable

     See https://github.

116. case class SkewReplicationB(maxKeysInMemory: Int = 1000000.0.toInt, maxReducerOutput: Int = 1.0E7.toInt) extends SkewReplication with Product with Serializable

     See https://github.

117. trait Sortable[+Self] extends AnyRef

118. abstract class Source extends Serializable

     Every source must have a correct toString method.

119. case class Stat(name: String, group: String = Stats.ScaldingGroup)(implicit uniqueIdCont: UniqueID) extends Product with Serializable

120. trait Stateful extends AnyRef

     A simple trait for releasable resource.

121. trait StreamOperations[+Self <: StreamOperations[Self]] extends Sortable[Self] with Serializable

     Implements reductions on top of a simple abstraction for the Fields-API We use the f-bounded polymorphism trick to return the type called Self in each operation.

122. case class StringField[T](id: String)(implicit ord: Ordering[T], mf: Option[Manifest[T]]) extends Field[T] with Product with Serializable

     Annotations

     @DefaultSerializer()

123. trait SuccessFileSource extends FileSource

     Ensures that a _SUCCESS file is present in the Source path, which must be a glob, as well as the requirements of FileSource.pathIsGood

124. abstract class TemplateSource extends SchemedSource

     This is a base class for template based output sources

125. case class TemplatedSequenceFile(basePath: String, template: String, sequenceFields: Fields = cascading.tuple.Fields.ALL, pathFields: Fields = cascading.tuple.Fields.ALL, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends TemplateSource with SequenceFileScheme with Product with Serializable

     An implementation of SequenceFile output, split over a template tap.

126. case class TemplatedTsv(basePath: String, template: String, pathFields: Fields = cascading.tuple.Fields.ALL, writeHeader: Boolean = false, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends TemplateSource with DelimitedScheme with Product with Serializable

     An implementation of TSV output, split over a template tap.

127. case class Test(buffers: (Source) ⇒ Option[Buffer[Tuple]]) extends TestMode with CascadingLocal with Product with Serializable

     Memory only testing for unit tests

128. trait TestMode extends Mode

129. class TestTapFactory extends Serializable

130. class TextLine extends FixedPathSource with TextLineScheme

131. trait TextLineScheme extends SchemedSource with Mappable[String]

     The fields here are ('offset, 'line)

132. abstract class TimePathedSource extends TimeSeqPathedSource

     This will automatically produce a globbed version of the given path.

133. abstract class TimeSeqPathedSource extends FileSource

134. class Tool extends Configured with org.apache.hadoop.util.Tool

135. case class Tsv(p: String, fields: Fields = cascading.tuple.Fields.ALL, skipHeader: Boolean = false, writeHeader: Boolean = false, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE) extends FixedPathSource with DelimitedScheme with Product with Serializable

     Tab separated value source

136. trait TupleArity extends AnyRef

     Mixed in to both TupleConverter and TupleSetter to improve arity safety of cascading jobs before we run anything on Hadoop.

137. trait TupleConverter[T] extends Serializable with TupleArity

     Typeclass to represent converting from cascading TupleEntry to some type T.

138. trait TupleGetter[T] extends Serializable

     Typeclass roughly equivalent to a Lens, which allows getting items out of a tuple.

139. trait TuplePacker[T] extends Serializable

     Typeclass for packing a cascading Tuple into some type T, this is used to put fields of a cascading tuple into Thrift, Protobuf, or case classes, for instance, but you can add your own instances to control how this is done.

140. trait TupleSetter[T] extends Serializable with TupleArity

     Typeclass to represent converting back to (setting into) a cascading Tuple This looks like it can be contravariant, but it can't because of our approach of falling back to the singleSetter, you really want the most specific setter you can get.

141. trait TupleUnpacker[T] extends Serializable

142. class TupleUnpackerException extends Exception

143. class TypedBufferOp[K, V, U] extends BaseOperation[Any] with Buffer[Any] with ScaldingPrepare[Any]

     In the typed API every reduce operation is handled by this Buffer

144. class TypedDelimited[T] extends FixedPathSource with DelimitedScheme with Mappable[T] with TypedSink[T]

     Allows you to set the types, prefer this: If T is a subclass of Product, we assume it is a tuple.

145. type TypedPipe[+T] = scalding.typed.TypedPipe[T]

146. trait TypedSeperatedFile extends Serializable

     Trait to assist with creating objects such as TypedTsv to read from separated files.

147. type TypedSink[-T] = scalding.typed.TypedSink[T]

148. trait TypedSink1[A] extends TypedSink[(A)]

149. trait TypedSink10[A, B, C, D, E, F, G, H, I, J] extends TypedSink[(A, B, C, D, E, F, G, H, I, J)]

150. trait TypedSink11[A, B, C, D, E, F, G, H, I, J, K] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K)]

151. trait TypedSink12[A, B, C, D, E, F, G, H, I, J, K, L] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L)]

152. trait TypedSink13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

153. trait TypedSink14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

154. trait TypedSink15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

155. trait TypedSink16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

156. trait TypedSink17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

157. trait TypedSink18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

158. trait TypedSink19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

159. trait TypedSink2[A, B] extends TypedSink[(A, B)]

160. trait TypedSink20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

161. trait TypedSink21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

162. trait TypedSink22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends TypedSink[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

163. trait TypedSink3[A, B, C] extends TypedSink[(A, B, C)]

164. trait TypedSink4[A, B, C, D] extends TypedSink[(A, B, C, D)]

165. trait TypedSink5[A, B, C, D, E] extends TypedSink[(A, B, C, D, E)]

166. trait TypedSink6[A, B, C, D, E, F] extends TypedSink[(A, B, C, D, E, F)]

167. trait TypedSink7[A, B, C, D, E, F, G] extends TypedSink[(A, B, C, D, E, F, G)]

168. trait TypedSink8[A, B, C, D, E, F, G, H] extends TypedSink[(A, B, C, D, E, F, G, H)]

169. trait TypedSink9[A, B, C, D, E, F, G, H, I] extends TypedSink[(A, B, C, D, E, F, G, H, I)]

170. type TypedSource[+T] = scalding.typed.TypedSource[T]

171. trait TypedSource1[A] extends TypedSource[(A)]

172. trait TypedSource10[A, B, C, D, E, F, G, H, I, J] extends TypedSource[(A, B, C, D, E, F, G, H, I, J)]

173. trait TypedSource11[A, B, C, D, E, F, G, H, I, J, K] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K)]

174. trait TypedSource12[A, B, C, D, E, F, G, H, I, J, K, L] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L)]

175. trait TypedSource13[A, B, C, D, E, F, G, H, I, J, K, L, M] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M)]

176. trait TypedSource14[A, B, C, D, E, F, G, H, I, J, K, L, M, N] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)]

177. trait TypedSource15[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)]

178. trait TypedSource16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]

179. trait TypedSource17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)]

180. trait TypedSource18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)]

181. trait TypedSource19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)]

182. trait TypedSource2[A, B] extends TypedSource[(A, B)]

183. trait TypedSource20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)]

184. trait TypedSource21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)]

185. trait TypedSource22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends TypedSource[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]

186. trait TypedSource3[A, B, C] extends TypedSource[(A, B, C)]

187. trait TypedSource4[A, B, C, D] extends TypedSource[(A, B, C, D)]

188. trait TypedSource5[A, B, C, D, E] extends TypedSource[(A, B, C, D, E)]

189. trait TypedSource6[A, B, C, D, E, F] extends TypedSource[(A, B, C, D, E, F)]

190. trait TypedSource7[A, B, C, D, E, F, G] extends TypedSource[(A, B, C, D, E, F, G)]

191. trait TypedSource8[A, B, C, D, E, F, G, H] extends TypedSource[(A, B, C, D, E, F, G, H)]

192. trait TypedSource9[A, B, C, D, E, F, G, H, I] extends TypedSource[(A, B, C, D, E, F, G, H, I)]

193. case class UniqueID(get: String) extends Product with Serializable

194. trait UtcDateRangeJob extends Job with DefaultDateRangeJob

195. type ValuePipe[+T] = scalding.typed.ValuePipe[T]

196. case class WritableSequenceFile[K <: Writable, V <: Writable](p: String, f: Fields, sinkMode: SinkMode = cascading.tap.SinkMode.REPLACE)(implicit evidence$3: Manifest[K], evidence$4: Manifest[V]) extends FixedPathSource with WritableSequenceFileScheme with LocalTapSource with TypedSink[(K, V)] with TypedSource[(K, V)] with Product with Serializable

197. trait WritableSequenceFileScheme extends SchemedSource

198. class XHandler extends AnyRef

     Provide handlers and mapping for exceptions

199. trait TupleConversions extends AnyRef

     Annotations

     @deprecated

     Deprecated

     (Since version 0.9.0) This trait does nothing now