Packages

p

ostrat

package ostrat

This is the root package for the Openstrat project. The top of this package contains, 32 bit Int based Colours, the Multiple type class, a show and persistence library using RCON (Name may change), Rich Compact Object Notation, array based compound value collections of same length elements, an Either based errors framework and general utilities.

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ostrat
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package gOne

    This is the package for the first example of an extremely simple simultaneous turn tile based game.

    This is the package for the first example of an extremely simple simultaneous turn tile based game. The game is created purely to illustrate and test fundamental algorithm and software patterns. It is not intended as an interesting game to play.

  2. package gThree
  3. package gTwo
  4. package geom

    The package name has been chosen to avoid clashing with "geometry" that may be use in other libraries This package contains geometry vectors and graphics.

    The package name has been chosen to avoid clashing with "geometry" that may be use in other libraries This package contains geometry vectors and graphics. Of particular note are the Pt2, GeomElem and GraphicElem class /traits. These are the foundation of the API and the library. A number of implementation Value classes of the Int and Double product classes defined in ostrat. 2d graphical objects for generalised use. They are of particular use for the generic canvas based classes defined in pCanv but can be used in any display framework and for printing.

  5. package p1783

    This p1783 package is the beginnings of a grand strategy development game starting in 1783.

  6. package p305

    This is the beginnings of a grand strategy game starting in BC305 covering Europe, North Africa and West Asia.

  7. package pAltReact
  8. package pCanv

    The package attempts to encapsulate the various abstract canvas traits while the actual objects that populate a canvas go in package geom.

  9. package pCard

    This is ancient code.

    This is ancient code. Not use how much is worth salvaging

  10. package pChess

    This is a package for Chess and Draughts (also known as Checkers).

    This is a package for Chess and Draughts (also known as Checkers). It has been included in the main Strat library, as useful to have code. Because they are finished games, with established rules and iconography. As opposed to applications like GOne, GTwo etc, which are super simple games merely created for the teaching of the use use of the ostrat libraries. And also as opposed to the games in the Dev module which are intended to be developed into interesting games which may at some point have their own individual repositories.

  11. package pCiv

    A civilisation development game.

  12. package pCloseOrder
  13. package pDev
  14. package pDraughts
  15. package pDung
  16. package pEarth

    This package and module is for Earth maps.

    This package and module is for Earth maps. In particular the tiling of the whole world in Hex grids, defining the changes over the course of history. This will be a data orientated module. It will also include terrain types to model terrain, both real and imagined for local maps and higher scales right up to 0.5 metres per tile However it won't generally include the data for these. The data for the real world will be organised according to a number of levels, which are likely to change over increasingly shorter historical time frames.

    1 Base elevation, relative to 1950 sea level, and relief. 2 Climate. 2 Sea level, shore lines, lake shore lines and river courses. 3 Land-use, both natural and human.

  17. package pFlags
  18. package pGrid

    This package has been deprecated.

    This package has been deprecated. It is being replaced by the prid package.

    This package works with hexagonal and Square tile grids. The tile objects themselves will not in the general case the contain grid coordinates, although * it may be necessary to include this data for complex Tile values interacting with their wider environment. Its fundamental components are the grid data itself. This is just a linear array of tile data. Compile-time typed grid data. So for example a chess board can be represented by a 64 element Arr, its context determines that it is to be interpreted as an 8 by 8 square grid. Grid descriptions that describe the grid representation in the Array and GridFunctions which implement Cood to T. The grid and grid-gui hierarchies currently contain a mix of new and old systems. The package name pGrid was chosen to allow you to use the name "grid" in your code.

  19. package pHtmlFac
  20. package pParse

    This is the RSON package.

    This is the RSON package. Readable Succinct Object Notation. It could be just as accurately be described as Readable Succinct Data Notation, but that wouldn't scan as well and indicate it as a better replacement for JSON. RSON uses the standard semicolon separated statements combined with multilevel bracket hierarchy syntax familiar from C, C++, Java and JavaScript. Its main innovations over JSON and XML are allowing statements to be partitioned into comma delineated clauses, the empty statement, the empty clause and type inference. It uses a context free operator precedence hierarchy, with the exception of allowing the 4 ( - + ~ !) operator to be used as prefix operators. Beyond this it generally follows Scala syntax where this doesn't conflict with the preceding rules. Unlike Scala statements must finish with a semicolon unless it is the last statement of a file or a bracket block. Allowing statements to end with a newline introduces horrendous ambiguities unless one is willing to go completely down the significant whitespace route and I'm not sure if that could work even work for such a general purpose basic syntax.

    The above allows it to combine a high level of human readability, succinctness, non-programmer / non-expert write-ability, programmer flexibility and composability and fast-parsing. The initial motivating use case was strategy games, which require huge amounts of modable date files. XML and JSON, the current defaults are simply not fit for purpose. RSON aims to break down the walls between game player, game modder, professional game artist, professional game scripter, professional imperative programming wizards in languages such as C / C++ and Rust and professional functional programming wizards in languages such as Scala, Haskell and Idris.

  21. package pReactor

    Clone of the classic Atoms game

  22. package pSJs
  23. package pSpace
  24. package pStrat

    Package for miscellaneous game utilities and data.

  25. package pWW2

    This pSimp is the beginnings of a WWII grand strategy game.

  26. package pWeb

    I'm just trying out a new package, not sure whether will use pWeb.

  27. package pZug
  28. package prid

    The tile grid package, replacing the old pGrid package.

    The tile grid package, replacing the old pGrid package. This package works with hexagonal and Square tile grids. There are separate class for the different types of Coordinates HCen, SqCen, HSide, etc. The tile objects themselves will not in the general case the contain grid coordinates, although it may be necessary to include this data for complex tile values interacting with their wider environment. Its fundamental components are the grid data itself. This is just a linear array of tile data. Compile-time typed grid data. So for example a chess board can be represented by a 64 element Arr, its context determines that it is to be interpreted as an 8 by 8 square grid. Grid descriptions that describe the grid representation in the Array and GridFunctions which implement Cood to T. The grid and grid-gui hierarchies currently contain a mix of new and old systems.

    The package name prid, short for package grid, was chosen to allow you to use the name "grid" in your code.

  29. package strat

Type Members

  1. final class AnyBuff[A] extends AnyVal with ArrayLike[A]

    Not sure if this class is necessary now that Arr take Any.

  2. class AnyBuild[B] extends ArrTBuilder[B, Arr[B]] with ArrTFlatBuilder[Arr[B]]

    The default Immutable Array based collection builder for the Arr[A] class.

  3. type AnyRefs = Arr[AnyRef]
  4. class AnyTypeExtensions[A] extends AnyRef

    Extension methods for Any type A.

  5. trait Approx[D] extends Equals
  6. case class Approx2DblsT[T](fArg1: (T) => Double, fArg2: (T) => Double, precisionDefault: Double = 1e-12) extends ApproxT[Double, T] with Product with Serializable
  7. trait ApproxDbl extends Approx[Double]
  8. implicit class ApproxImplicitClass[D, T] extends AnyRef

    Extension methods for approximation type class.

  9. trait ApproxT[D, T] extends AnyRef
  10. final class Area extends AnyVal

    Not sure about this class.

  11. final class Arr[+A] extends AnyVal with ArrImut[A]

    The immutable Array based class for types without there own specialised ArrImut collection classes.

    The immutable Array based class for types without there own specialised ArrImut collection classes. It Inherits the standard foreach, map, flatMap and fold and their variations' methods from ArrayLike.

  12. trait ArrArrayDbl[A <: ArrayDblBased] extends ArrImut[A]
  13. trait ArrArrayDblBuild[A <: ArrayDblBased, ArrT <: ArrArrayDbl[A]] extends ArrTBuilder[A, ArrT]

    This is the builder for Arrays Arrays of Double.

    This is the builder for Arrays Arrays of Double. It is not the builder for Arrays of Double.

  14. class ArrArrayDblEq[A <: ArrayDblBased, ArrT <: ArrArrayDbl[A]] extends EqT[ArrT]
  15. trait ArrBaseOff[A, ArrT <: ArrImut[A]] extends Any
  16. trait ArrBuildLowPriority extends AnyRef
  17. trait ArrFlatBuildLowPriority extends AnyRef
  18. trait ArrImut[+A] extends ArrayLike[A]

    Base trait for specialised immutable Arrays.

    Base trait for specialised immutable Arrays. The final classes extend AnyVal using standard Java /Javascript Arrays for their underlying storage. A lot of the time this is a compile time wrapper with no boxing run cost.

  19. final class ArrOff[A] extends AnyVal with ArrBaseOff[A, Arr[A]]

    Immutable heapless iterator for Arr.

  20. abstract class ArrProdDbl4Persist[A <: Dbl4Elem, ArrA <: Dbl4sArr[A]] extends DblNsArrPersist[A, ArrA]

    Persists Collection classes.

  21. trait ArrTBuilder[B, ArrB <: ArrImut[B]] extends ArrTBuilderCommon[ArrB]

    A type class for the building of efficient compact Immutable Arrays.

    A type class for the building of efficient compact Immutable Arrays. Instances for this type class for classes / traits you control should go in the companion object of B not the companion object of BB. This is different from the related ArrBinder[BB] type class where instance should go into the BB companion object. The type parameter is named B rather than A, because normally this will be found by an implicit in the context of a function from A => B or A => M[B]. The methods of this trait mutate and therefore must be used with care. Where ever possible they should not be used directly by end users.

  22. trait ArrTBuilderCommon[ArrB <: ArrImut[_]] extends AnyRef

    A common trait inherited by ArrTBuilder and ArrTFlatBuider.

  23. trait ArrTFlatBuilder[ArrT <: ArrImut[_]] extends ArrTBuilderCommon[ArrT]

    A type class for the building of efficient compact Immutable Arrays through a flatMap method.

    A type class for the building of efficient compact Immutable Arrays through a flatMap method. Instances for this type class for classes / traits you control should go in the companion object of BB. This is different from the related ArrTBuilder[BB] type class where the instance should go into the B companion object.

  24. implicit class ArrayBufferDoubleExtensions extends AnyRef
  25. implicit class ArrayBufferExtensions[A] extends AnyRef
  26. trait ArrayDblBased extends Any
  27. trait ArrayDoubleBuff[A <: ArrayDblBased] extends ArrayLike[A]

    This is a buffer class for Arrays of Double.

    This is a buffer class for Arrays of Double. It is not a Buffer class for Arrays.

  28. final class ArrayExtensions[A] extends AnyVal

    Extension methods for Array[A] class

  29. implicit class ArrayIntExtension extends AnyRef
  30. trait ArrayLike[+A] extends ArrayLikeBase[A]

    This the base trait for all collections based on Array like classes, Arrays, ArrayBuffers etc.

    This the base trait for all collections based on Array like classes, Arrays, ArrayBuffers etc. that compile time platform Array classes. So currently there are just two classes for each type A, An ArrImut that wraps a standard immutable Array to produce an immutable array, and a ArrBuff that wraps an ArrayBuffer. Currently this just in a standard ArrayBuffer. Where A is a compound value types or an AnyVal type.

  31. trait ArrayLikeBase[A] extends Any

    Not sure how useful this trait is.

    Not sure how useful this trait is. It has been created for the OptRefs trait because the Scala2 compiler has problems extending ArrayLike.

  32. case class ArrayLikeShow[A, R <: ArrayLike[A]](evA: ShowT[A]) extends ShowTSeqLike[A, R] with Product with Serializable
  33. final class ArrayValueNElemExtensions[A <: ValueNElem] extends AnyVal

    Extension methods for Array[A <: ValueNElem] class

  34. class Bad[+A] extends EMon[A]

    The errors case of EMon[+A].

    The errors case of EMon[+A]. This corresponds, but is not functionally equivalent to an Either[List[String], +A] based Left[List[String], +A].

  35. final case class Bad2[A1, A2](errs: Strings) extends EMon2[A1, A2] with Product with Serializable
  36. final class Bad3[A1, A2, A3] extends EMon3[A1, A2, A3]
  37. final class BooleanBuff extends AnyVal with ArrayLike[Boolean]
  38. final class BooleanExtensions extends AnyVal
  39. final class Booleans extends AnyVal with ArrImut[Boolean]

    An immutable Array based class for Booleans.

  40. type Buff[A] = ArrayBuffer[A]
  41. class CharExtensions extends AnyRef
  42. final class Chars extends AnyVal with ArrImut[Char]

    Efficient immutable Array based collection for Chars.

  43. final class CharsOff extends AnyVal with ArrBaseOff[Char, Chars]

    Immutable heapless iterator for Char arrays.

  44. final class Colour extends AnyVal with FillFacet with Int1Elem

    The argbValue must start with 0xFF if the default full opacity is required.

    The argbValue must start with 0xFF if the default full opacity is required. So 0xFFFF0000 gives full opacity Red

  45. final class ColourBuff extends AnyVal with Int1sBuffer[Colour, Colours]

    ArrayBuffer based buffer class for Colours.

  46. final class Colours extends AnyVal with Int1sArr[Colour]

    Specialist Array[Int] based class for Colours.

  47. trait Dbl1Elem extends DblNElem

    An object that can be constructed from a single Double.

    An object that can be constructed from a single Double. These are used in Dbl1sArr Array[Int] based collections.

  48. trait Dbl1sArr[A <: Dbl1Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl1Elems.

  49. trait Dbl2Elem extends DblNElem

    An object that can be constructed from 2 Doubles.

    An object that can be constructed from 2 Doubles. These are used as elements in Dbl2sArr Array[Double] based collections.

  50. trait Dbl2sArr[A <: Dbl2Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl2Elems.

  51. trait Dbl2sArrBuilder[B <: Dbl2Elem, ArrB <: Dbl2sArr[B]] extends DblNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for Dbl2Arr final classes.

    Trait for creating the ArrTBuilder type class instances for Dbl2Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of type B, which will extend Dbl2Elem. The first type parameter is called B, because it corresponds to the B in map[B](f: A => B)(implicit build: ArrTBuilder[B, ArrB]): ArrB function.

  52. trait Dbl2sArrCompanion[A <: Dbl2Elem, ArrA <: Dbl2sArr[A]] extends DblNsArrCompanion[A, ArrA]

    Class for the singleton companion objects of Dbl2sArr final classes to extend.

  53. trait Dbl2sArrFlatBuilder[B <: Dbl2Elem, ArrB <: Dbl2sArr[B]] extends DblNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTFlatBuilder type class instances for Dbl2Arr final classes.

    Trait for creating the ArrTFlatBuilder type class instances for Dbl2Arr final classes. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because it corresponds to the B in map[B](f: A => B)(implicit build: ArrTBuilder[B, ArrB]): ArrB function.

  54. abstract class Dbl2sArrPersist[A <: Dbl2Elem, M <: Dbl2sArr[A]] extends DblNsArrPersist[A, M]

    Persists and assists in building DblNsArrs.

  55. trait Dbl2sBuffer[A <: Dbl2Elem] extends DblNsBuffer[A]

    A specialised flat ArrayBuffer[Double] based trait for Dbl2Elems collections.

  56. trait Dbl3Elem extends DblNElem

    An object that can be constructed from 3 Doubles.

    An object that can be constructed from 3 Doubles. These are used in Dbl3sArr Array[Double] based collections.

  57. trait Dbl3sArr[A <: Dbl3Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl3Elems.

  58. trait Dbl3sArrBuilder[B <: Dbl3Elem, ArrB <: Dbl3sArr[B]] extends DblNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for Dbl3Arr final classes.

    Trait for creating the ArrTBuilder type class instances for Dbl3Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of type B, which will extend Dbl3Elem. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  59. abstract class Dbl3sArrCompanion[A <: Dbl3Elem, ArrA <: Dbl3sArr[A]] extends DblNsArrCompanion[A, ArrA]

    Class for the singleton companion objects of Dbl3sArr final classes to extend.

  60. trait Dbl3sArrFlatBuilder[B <: Dbl3Elem, ArrB <: Dbl3sArr[B]] extends DblNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTFlatBuilder type class instances for Dbl3Arr final classes.

    Trait for creating the ArrTFlatBuilder type class instances for Dbl3Arr final classes. Instances for the for classes / traits you control, should go in the companion object of the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  61. abstract class Dbl3sArrPersist[A <: Dbl3Elem, M <: Dbl3sArr[A]] extends DblNsArrPersist[A, M]

    Persists Dbl3sArrs.

  62. trait Dbl3sBuffer[A <: Dbl3Elem] extends DblNsBuffer[A]

    A specialised flat ArrayBuffer[Double] based trait for Dbl3Elems collections.

  63. trait Dbl4Elem extends DblNElem

    An object that can be constructed from 4 Doubles.

    An object that can be constructed from 4 Doubles. These are used in Dbl4sArr Array[Double] based collections.

  64. trait Dbl4sArr[A <: Dbl4Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl4Elems.

  65. trait Dbl4sArrBuilder[B <: Dbl4Elem, ArrB <: Dbl4sArr[B]] extends DblNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for Dbl4Arr final classes.

    Trait for creating the ArrTBuilder type class instances for Dbl4Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of type B, which will extend Dbl4Elem. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  66. abstract class Dbl4sArrCompanion[A <: Dbl4Elem, ArrA <: Dbl4sArr[A]] extends AnyRef

    Class for the singleton companion objects of Dbl4sArr final classes to extend.

  67. trait Dbl4sArrFlatBuilder[B <: Dbl4Elem, ArrB <: Dbl4sArr[B]] extends DblNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Dbl4Arr final classes.

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Dbl4Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of type B, which will extend Dbl4Elem. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  68. trait Dbl4sBuffer[A <: Dbl4Elem] extends DblNsBuffer[A]

    A specialised flat ArrayBuffer[Double] based trait for Dbl4Elems collections.

  69. trait Dbl5Elem extends DblNElem

    An object that can be constructed from 5 Doubles.

    An object that can be constructed from 5 Doubles. These are used in Dbl5sArr Array[Double] based collections.

  70. trait Dbl5sArr[A <: Dbl5Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl5Elems.

  71. abstract class Dbl5sArrCompanion[A <: Dbl5Elem, ArrA <: Dbl5sArr[A]] extends AnyRef

    Helper class for companion objects of final Dbl5sArr classes.

  72. abstract class Dbl5sArrPersist[A <: Dbl5Elem, ArrA <: Dbl5sArr[A]] extends DblNsArrPersist[A, ArrA]

    Both Persists and Builds Dbl5sArr Collection classes.

  73. trait Dbl6Elem extends DblNElem

    An object that can be constructed from 6 Doubles.

    An object that can be constructed from 6 Doubles. These are used in Dbl6sArr Array[Double] based collections.

  74. trait Dbl6sArr[A <: Dbl6Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl6Elems.

  75. abstract class Dbl6sArrCompanion[A <: Dbl6Elem, ArrA <: Dbl6sArr[A]] extends AnyRef

    Helper class for companion objects of final Dbl6sArr classes.

  76. trait Dbl7Elem extends DblNElem

    An object that can be constructed from 7 Doubles.

    An object that can be constructed from 7 Doubles. These are used in Dbl7sArr Array[Double] based collections.

  77. trait Dbl7sArr[A <: Dbl7Elem] extends DblNsArr[A]

    A specialised immutable, flat Array[Double] based collection of a type of Dbl7Elems.

  78. abstract class Dbl7sArrCompanion[A <: Dbl7Elem, ArrA <: Dbl7sArr[A]] extends AnyRef

    Helper class for companion objects of final Dbl7sArr classes.

  79. trait DblNElem extends ValueNElem

    An object that can be constructed from N Doubles.

    An object that can be constructed from N Doubles. These are used as elements in DblNsArr Array[Double] based collections.

  80. trait DblNsArr[A <: DblNElem] extends ValueNsArr[A] with ArrayDblBased

    Base trait for Array[Double] based collections of Products of Doubles.

  81. trait DblNsArrBuilder[B <: DblNElem, ArrB <: DblNsArr[B]] extends ValueNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for DblNsArr final classes.

    Trait for creating the ArrTBuilder type class instances for DblNsArr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  82. trait DblNsArrCompanion[A <: DblNElem, ArrA <: DblNsArr[A]] extends ValueNArrCompanion[A, ArrA]

    Helper trait for Companion objects of DblNsArr classes.

  83. trait DblNsArrFlatBuilder[B <: DblNElem, ArrB <: DblNsArr[B]] extends ValueNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for DblNsArr final classes.

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for DblNsArr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  84. abstract class DblNsArrPersist[A <: DblNElem, M <: DblNsArr[A]] extends ValueNsArrPersist[A, M] with EqT[M]

    Persists DblNsArrs.

  85. trait DblNsBuffer[A <: DblNElem] extends ValueNsBuffer[A]

    Specialised flat ArrayBuffer[Double] based collection class.

  86. final class Dbls extends AnyVal with ArrImut[Double]

    An immutable Array based class for Doubles.

  87. final class DblsBuff extends AnyVal with ArrayLike[Double]
  88. final class DoubleImplicit extends AnyVal

    Extension class for Double.

    Extension class for Double. This is created as a separate class to keep down the size of the package object.

  89. sealed trait EMon[+A] extends AnyRef

    An Errors handling class.

    An Errors handling class. Consider changing name to EHan. The main ways to consume the final result of the flatMap operation are fold, getElse, foreach and forEither. This corresponds, but is not functionally equivalent to an Either[StrList, A] or Either[List[String], +A]. There are advantages to having a separate class and I find that I rarely use Either apart from with standard errors as the Left type. However use the methods biMap, to Either, eitherMap and eitherFlatMap when interoperability with Either is required. In my view Either[T] class is redundant and is rarely used except as an errors handler. So it makes sense to use a dedicated class.

  90. sealed trait EMon2[+A1, +A2] extends AnyRef
  91. sealed trait EMon3[+A1, +A2, +A3] extends AnyRef
  92. type ERefs[A <: AnyRef] = EMon[Arr[A]]
  93. class Eq1T[A1, R] extends EqT[R]
  94. case class Eq2DblsT[R](fArg1: (R) => Double, fArg2: (R) => Double) extends Eq2T[Double, Double, R] with Product with Serializable
  95. trait Eq2T[A1, A2, R] extends EqT[R]

    Equality type class trait for Product 2.

  96. class Eq3T[A1, A2, A3, R] extends EqT[R]

    Equality type class trait for Product 3.

  97. class Eq4T[A1, A2, A3, A4, R] extends EqT[R]

    Equality type class trait for Product 4.

  98. trait EqT[A] extends AnyRef

    Equals type class trait.

  99. implicit class EqerImplicit[T] extends AnyRef
  100. final class Floats extends AnyVal with ArrImut[Float]

    Immutable Array based class for Floats.

  101. final class FloatsBuff extends AnyVal with ArrayLike[Float]
  102. trait Functor[F[_]] extends AnyRef

    The functor type class.

  103. implicit class FunitRichImp extends AnyRef
  104. final class GMetres extends AnyVal with MetricLength

    Length measure in GigaMetres or millions of kilometres.

  105. final case class Good[+A](value: A) extends EMon[A] with Product with Serializable

    The Good sub class of EMon[+A].

    The Good sub class of EMon[+A]. This corresponds, but is not functionally equivalent to an Either[List[String], +A] based Right[Refs[String], +A].

  106. final case class Good2[A1, A2](a1: A1, a2: A2) extends EMon2[A1, A2] with Product with Serializable
  107. final case class Good3[+A1, +A2, +A3](a1: A1, a2: A2, a3: A3) extends EMon3[A1, A2, A3] with Product with Serializable
  108. trait ImperialLength extends Length

    Common trait for metric units of length.

  109. trait Int1Elem extends IntNElem

    An object that can be constructed from a single Int.

    An object that can be constructed from a single Int. These are used in Int1sArr Array[Int] based collections.

  110. trait Int1sArr[A <: Int1Elem] extends IntNsArr[A]

    A specialised immutable, flat Array[Int] based collection of a type of Int1Elems.

  111. trait Int1sArrBuilder[A <: Int1Elem, ArrT <: Int1sArr[A]] extends IntNsArrBuilder[A, ArrT]

    Trait for creating the ArrTBuilder type class instances for Int1Arr final classes.

    Trait for creating the ArrTBuilder type class instances for Int1Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  112. trait Int1sArrFlatBuilder[A <: Int1Elem, ArrT <: Int1sArr[A]] extends IntNsArrFlatBuilder[A, ArrT]

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Int1Arr final classes.

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Int1Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  113. trait Int1sBuffer[A <: Int1Elem, M <: Int1sArr[A]] extends IntNsBuffer[A]

    A specialised flat ArrayBuffer[Int] based trait for Int1Elems collections.

  114. trait Int2Elem extends IntNElem

    An object that can be constructed from 2 Ints.

    An object that can be constructed from 2 Ints. These are used in Int2sArr Array[Int] based collections.

  115. trait Int2sArr[A <: Int2Elem] extends IntNsArr[A]

    A specialised immutable, flat Array[Int] based collection of a type of Int2Elems.

  116. trait Int2sArrBuilder[B <: Int2Elem, ArrB <: Int2sArr[B]] extends IntNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for Int2Arr final classes.

    Trait for creating the ArrTBuilder type class instances for Int2Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. The first type parameter is called B a sub class of Int2Elem, because to corresponds to the B in the map(f: A => B): ArrB function.

  117. abstract class Int2sArrCompanion[A <: Int2Elem, ArrA <: Int2sArr[A]] extends IntNArrCompanion[A, ArrA]

    Helper class for companion objects of final Int2sArr classes.

  118. trait Int2sArrFlatBuilder[B <: Int2Elem, ArrB <: Int2sArr[B]] extends IntNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Int2Arr final classes.

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for Int2Arr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. Instances for should go in the companion object the ArrT final class. The first type parameter is called B a sub class of Int2Elem, because to corresponds to the B in the map(f: A => B): ArrB function.

  119. abstract class Int2sArrPersist[A <: Int2Elem, M <: Int2sArr[A]] extends IntNsArrPersist[A, M]

    Class to persist specialised flat Array[Int] based collections of Int2Elems.

  120. trait Int2sBuffer[A <: Int2Elem, M <: Int2sArr[A]] extends IntNsBuffer[A]

    A specialised flat ArrayBuffer[Int] based trait for Int2Elems collections.

  121. trait Int4Elem extends IntNElem

    An object that can be constructed from 4 Ints.

    An object that can be constructed from 4 Ints. These are used in Int4sArr Array[Int] based collections.

  122. trait Int4sArr[A <: Int4Elem] extends IntNsArr[A]

    A specialised immutable, flat Array[Int] based collection of a type of Int4Elems.

  123. abstract class Int4sArrCompanion[A <: Int4Elem, M <: Int4sArr[A]] extends AnyRef

    Class for the singleton companion objects of Int4sArr final classes to extend.

  124. abstract class Int4sArrPersist[B <: Int4Elem, ArrB <: Int4sArr[B]] extends IntNsArrPersist[B, ArrB]

    Class to persist specialised flat Array[Int] based Int4sArr collection classes.

  125. trait Int4sBuffer[A <: Int4Elem, M <: Int4sArr[A]] extends IntNsBuffer[A]

    A specialised flat ArrayBuffer[Int] based trait for Int4Elems collections.

  126. final class IntBuff extends AnyVal with ArrayLike[Int]
  127. final class IntExtensions extends AnyVal

    Extension methods for Int.

  128. trait IntNArrCompanion[A <: IntNElem, ArrA <: IntNsArr[A]] extends ValueNArrCompanion[A, ArrA]

    Helper trait for Companion objects of IntNArr collection classes, where the type parameter ArrA is the IntNElem type of the of the collection class.

  129. trait IntNElem extends ValueNElem

    A class that can be construct from a fixed number of Ints can be stored as an Array[Int] of primitive values.

  130. trait IntNsArr[A <: IntNElem] extends ValueNsArr[A]

    An immutable collection of Elements that inherit from a Product of an Atomic value: Double, Int, Long or Float.

    An immutable collection of Elements that inherit from a Product of an Atomic value: Double, Int, Long or Float. They are stored with a backing Array[Int] They are named ProductInts rather than ProductIs because that name can easlily be confused with ProductI1s.

  131. trait IntNsArrBuilder[B <: IntNElem, ArrB <: IntNsArr[B]] extends ValueNsArrBuilder[B, ArrB]

    Trait for creating the ArrTBuilder type class instances for IntNsArr final classes.

    Trait for creating the ArrTBuilder type class instances for IntNsArr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  132. trait IntNsArrFlatBuilder[B <: IntNElem, ArrB <: IntNsArr[B]] extends ValueNsArrFlatBuilder[B, ArrB]

    Trait for creating the ArrTFlatBuilder type class instances for IntNsArr final classes.

    Trait for creating the ArrTFlatBuilder type class instances for IntNsArr final classes. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  133. abstract class IntNsArrPersist[A <: IntNElem, M <: IntNsArr[A]] extends ValueNsArrPersist[A, M]

    Class to persist specialised flat Array[Int] based collections.

  134. trait IntNsBuffer[A <: IntNElem] extends ValueNsBuffer[A]

    Specialised flat ArrayBuffer[Int] based collection class.

  135. final class Ints extends AnyVal with ArrImut[Int]

    Immutable Array based class for Ints.

    Immutable Array based class for Ints. There are no concat methods, as Ints has no type parameter and can not be widened.

  136. trait IsType[A <: AnyRef] extends AnyRef
  137. implicit class IterableAnyRefImplicit[A <: AnyRef] extends AnyRef
  138. final class IterableExtensions[A] extends AnyVal

    Extension methods for Iterable[A].

  139. final class IterableValueNElemExtensions[A <: ValueNElem] extends AnyVal

    Extension methods for Iterable[A <: ValueNElem].

  140. final class KMetres extends AnyVal with MetricLength

    Length in kilometres.

  141. trait Length extends Ordered[Length]

    A quantity or measurement of length.

    A quantity or measurement of length. The final classes include Metres, KMetres. The purpose of the separate classes is for displaying values. 100M and 0.1KMetres have the same value but will be displayed differently.

  142. final class ListExtensions[A] extends AnyVal
  143. trait Long1Elem extends LongNElem

    An object that can be constructed from a single Long.

    An object that can be constructed from a single Long. These are used in Long1Arr Array[Int] based collections.

  144. trait Long1sArr[A <: Long1Elem] extends LongNsArr[A]

    A specialised immutable, flat Array[Long] based collection of a type of Long1Elems.

  145. trait Long1sBuffer[A <: Long1Elem, ArrA <: Long1sArr[A]] extends LongNsBuffer[A]

    A specialised flat ArrayBuffer[long] based trait for Long1Elems collections.

  146. final class LongExtensions extends AnyVal
  147. trait LongNElem extends ValueNElem

    A class that can be constructed from a fixed number of Longs.

    A class that can be constructed from a fixed number of Longs. It can be stored as an Array[Long] of primitive values.

  148. trait LongNsArr[A <: LongNElem] extends ValueNsArr[A]

    Base trait for Array[Long] based collections of Products of Longs.

  149. abstract class LongNsArrBuilders[B <: LongNElem, ArrB <: LongNsArr[B]] extends ValueNsArrPersist[B, ArrB]

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for LongNsArr final classes.

    Trait for creating the ArrTBuilder and ArrTFlatBuilder type class instances for LongNsArr final classes. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. Instances for should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  150. trait LongNsBuffer[A <: LongNElem] extends ValueNsBuffer[A]

    Specialised flat ArrayBuffer[Double] based collection class.

  151. final class Longs extends AnyVal with ArrImut[Long]

    Immutable Array based class for Longs.

  152. final class LongsBuff extends AnyVal with ArrayLike[Long]
  153. final class MMetres extends AnyVal with MetricLength

    Length in megametres or thousands of kilometres.

  154. final class MMiles extends AnyVal with ImperialLength

    Length in millions of miles.

  155. final class Metres extends AnyVal with MetricLength

    Length in metres.

  156. trait MetricLength extends Length

    Common trait for metric units of length.

  157. final class Miles extends AnyVal with ImperialLength

    Length in miles.

  158. final class MinesBuff extends AnyVal with Dbl2sBuffer[MyDbl2]
  159. case class Multiple[+A](value: A, num: Int) extends Product with Serializable

    The Multiple type class allow you to represent multiple values of type A.

    The Multiple type class allow you to represent multiple values of type A. Implicit conversion in package object.

  160. case class MyDbl2(a: Double, b: Double) extends Dbl2Elem with Product with Serializable

    An example of a class that is based on the product of 2 Doubles.

    An example of a class that is based on the product of 2 Doubles. This class, MyDbl2s and their companion objects show you the boiler plate necessary to create and use custom efficient flat Array based immutable collection classes.

  161. final class MyDbl2s extends AnyVal with Dbl2sArr[MyDbl2]
  162. trait NoOpt[A] extends Opt[A]
  163. type Not[T] = AnyRef { type L[U] = ostrat.NotSubTypeOf[U,T] }
  164. trait NotSubTypeOf[A, B] extends AnyRef
  165. trait Opt[A] extends Any
  166. sealed trait OptColour extends Opt[Colour]
  167. sealed trait OptEither[+A, +B] extends AnyRef

    An Optional Either.

    An Optional Either. The value can be an A a B or none.

  168. trait OptInt extends Opt[Int]
  169. final case class OptRef[+A <: AnyRef](value: A) extends AnyVal with Product with Serializable
  170. final class OptRefs[A <: AnyRef] extends AnyVal with ArrayLikeBase[OptRef[A]]

    OptRefs is an array based collection of optional values, that uses nulls for implementation.

    OptRefs is an array based collection of optional values, that uses nulls for implementation. The collection use should not have to interact with the null values directly.

  171. class OptionExtensions[A] extends AnyRef
  172. type ParseExpr = Expr
  173. trait Persist[T] extends ShowT[T] with UnShow[T]

    A convenience trait type class trait for persistence, that combines the ShowT and UnShow type classes.

    A convenience trait type class trait for persistence, that combines the ShowT and UnShow type classes. Most if not all final classes that inherit from this trait will require type class instances of ShowT and UnShowT to implement Persist's members. It is most important that these implicit parameter instances be specified as separate ShowT and UnShowT parameters. Do not combine them into a Persist parameter. There are no implicit instances for Int, Double, List etc in the Persist companion object, the Persist components for these standard types will be found in the ShowT and UnShow companion objects.

  174. class Persist2[A1, A2, R] extends Show2T[A1, A2, R] with PersistShowProductT[R]

    Persistence class for product 2 type class.

    Persistence class for product 2 type class. It ShowTs and UnShows objects with 2 logical parameters.

  175. trait Persist2Base[A1, A2, R] extends PersistBase

    A base trait for Show2T and UnShow2

  176. class Persist2Dbls[R <: Show2Dbls] extends Persist2Elem[Double, Double, R]

    Persistence class for types that extends Show2Dl.

  177. class Persist2Elem[A1, A2, R <: Show2[A1, A2]] extends Show2ElemT[A1, A2, R] with PersistProduct[R]

    Persist type class for types that extends Show2.

  178. class Persist2Ints[R <: Show2Ints] extends Persist2Elem[Int, Int, R]

    Persistence type class for types that extend Show2Ints.

  179. class Persist3[A1, A2, A3, R] extends Show3T[A1, A2, A3, R] with PersistShowProductT[R]

    Persistence class for 3 logical parameter product types.

  180. trait PersistBase extends AnyRef
  181. trait PersistCompound[R] extends ShowCompoundT[R] with Persist[R]

    Persistence base trait for PersistCase and PersistSeqLike.

    Persistence base trait for PersistCase and PersistSeqLike. Some methods probably need to be moved down into sub classes.

  182. abstract class PersistIterable[A, R <: Iterable[A]] extends PersistSeqLike[A, R] with ShowIterable[A, R]
  183. trait PersistProduct[R] extends Persist[R]

    The base trait for the persistence of algebraic product types, including case classes.

    The base trait for the persistence of algebraic product types, including case classes. Note the arity of the product, its size is based on the number of logical parameters. For example, a LineSeg is a product 2, it has a start point and an end point, although its is stored as 4 parameters xStart, yStart, xEnd, yEnd.

  184. class PersistSeqImplicit[A] extends PersistIterable[A, Seq[A]]
  185. abstract class PersistSeqLike[A, R] extends ShowTSeqLike[A, R] with PersistCompound[R]
  186. trait PersistShowProductT[R] extends PersistProduct[R] with ShowProductT[R]
  187. trait PersistShowerProduct[R <: Show] extends PersistProduct[R]
  188. abstract class PersistSimple[A] extends ShowSimpleT[A] with Persist[A]

    A Persist class described by a single value.

    A Persist class described by a single value. This may be removed. Its not clear whether this means a single token or not.

  189. abstract class PersistSingletons[A <: ShowSingleton] extends PersistSimple[A]

    I think this class may be redundant and can be replace by a more general PersistSum class for displaying algebraic sum types.

  190. abstract class PersistSum2[ST <: AnyRef, A1 <: ST, A2 <: ST] extends ShowSum2[ST, A1, A2] with UnShowSum2[ST, A1, A2] with Persist[ST]
  191. trait ProductLongsCompanion[A <: LongNElem, ArrA <: LongNsArr[A]] extends ValueNArrCompanion[A, ArrA]

    Helper trait for Companion objects of LongNsArr classes.

  192. implicit class RangeExtensions extends AnyRef
  193. implicit class RefBufferExtensions[A <: AnyRef] extends AnyRef

    Needs Changing.

  194. type RefTag[A] = ClassTag[A]
  195. type RefsMulti[A <: AnyRef] = Arr[Multiple[A]]
  196. final class Rval extends AnyVal

    Helper class for constructing Strings from ShowT implicit instances on objects.

  197. class SeqExtensions[A] extends AnyRef

    Extension methods for the Seq[A] class.

    Extension methods for the Seq[A] class. These are bought into scope by the seqToImplicit method in the package object.

  198. final class Setting extends AnyVal

    Class for creating RSOn settings.

  199. trait Show extends Any

    A trait for providing an alternative to toString.

    A trait for providing an alternative to toString. USing this trait can be convenient, but at some level of the inheritance the type must provide a ShowT type class instance. It is better for the ShowT type class instance to delegate to this trait than have the toString method delegate to the ShowT type class instance in the companion object. Potentially that can create initialisation order problems, but at the very least it can increase compile times.

  200. trait Show2[A1, A2] extends ShowProduct

    Trait for Show for a product of 2 logical elements.

    Trait for Show for a product of 2 logical elements. This trait is implemented directly by the type in question, unlike the corresponding Show2T trait which externally acts on an object of the specified type to create its String representations. For your own types it is better to inherit from Show2 and then use Show2ElemT or Persist2ElemT to create the type class instance for ShowT. The Show2ElemT or Persist2Elem class will delegate to Show2 for some of its methods. It is better to use Show2 to override toString method than delegating the toString override to a Show2T instance.

  201. trait Show2Base32s extends Show2[Int, Int] with Int2Elem

    Trait for Show for product of 2 Ints.

    Trait for Show for product of 2 Ints. This trait is implemented directly by the type in question, unlike the corresponding Show2IntsT trait which externally acts on an object of the specified type to create its String representations. For your own types ShowProduct is preferred over Show2T.

  202. trait Show2Base32sT[R <: Show2Base32s] extends Show2ElemT[Int, Int, R]

    A trait for making quick ShowT instances for products of 2 Ints persisted in Base32.

  203. trait Show2Dbls extends Show2[Double, Double] with Dbl2Elem

    Trait for Show for product of 2 Doubles.

    Trait for Show for product of 2 Doubles. This trait is implemented directly by the type in question, unlike the corresponding Show2DblsT trait which externally acts on an object of the specified type to create its String representations. For your own types ShowProduct is preferred over Show2T.

  204. trait Show2DblsT[R <: Show2Dbls] extends Show2ElemT[Double, Double, R]

    A trait for making quick ShowT instances for products of 2 Doubles.

  205. trait Show2ElemT[A1, A2, R <: Show2[A1, A2]] extends ShowElemT[R]
  206. trait Show2Ints extends Show2[Int, Int] with Int2Elem

    Trait for Show for product of 2 Ints.

    Trait for Show for product of 2 Ints. This trait is implemented directly by the type in question, unlike the corresponding Show2IntsT trait which externally acts on an object of the specified type to create its String representations. For your own types ShowProduct is preferred over Show2T.

  207. trait Show2IntsT[R <: Show2Ints] extends Show2ElemT[Int, Int, R]

    A trait for making quick ShowT instances for products of 2 Ints.

  208. trait Show2T[A1, A2, R] extends ShowProductT[R] with Persist2Base[A1, A2, R]

    Show type class for 2 parameter case classes.

  209. class Show2TExtensions[A1, A2, -T] extends AnyRef
  210. trait Show3[A1, A2, A3] extends ShowProduct

    Trait for Show for a product of 3 logical elements.

    Trait for Show for a product of 3 logical elements. This trait is implemented directly by the type in question, unlike the corresponding Show3T trait which externally acts on an object of the specified type to create its String representations. For your own types it is better to inherit from Show3 and then use Show3ElemT or Persist3ElemT to create the type class instance for ShowT. The Show3ElemT or Persist3Elem class will delegate to Show3 for some of its methods. It is better to use Show3 to override toString method than delegating the toString override to a Show3T instance.

  211. trait Show3Dbls extends Show3[Double, Double, Double] with Dbl3Elem

    Trait for Show for product of 2 Doubles.

    Trait for Show for product of 2 Doubles. This trait is implemented directly by the type in question, unlike the corresponding Show2DblsT trait which externally acts on an object of the specified type to create its String representations. For your own types ShowProduct is preferred over Show2T.

  212. class Show3T[A1, A2, A3, R] extends Eq3T[A1, A2, A3, R] with ShowProductT[R]

    Show type class for 3 parameter case classes.

  213. abstract class Show4T[A1, A2, A3, A4, R] extends ShowProductT[R]

    Show type class for 4 parameter case classes.

  214. class Show5T[A1, A2, A3, A4, A5, R] extends ShowProductT[R]

    Show type class for 5 parameter case classes.

  215. class Show6T[A1, A2, A3, A4, A5, A6, R] extends ShowProductT[R]

    Show type class for 5 parameter case classes.

  216. trait ShowCompoundT[R] extends ShowT[R]

    Show trait for Compound types contain elements, requiring the Show class or classes for the type or types of the constituent elements.

  217. trait ShowElemT[R <: Show] extends ShowT[R]

    A sub trait of the ShowT sub class where the type parameter of ShowT extends Show.

    A sub trait of the ShowT sub class where the type parameter of ShowT extends Show. This allows the ShowT type class to delegate to the Show class for the implementation of its strT and ShowT methods. It is better to use Show and ShowElemT for types you control than have the toString method delegate to the ShowT type class instance in the companion object. Potentially that can create initialisation order problems, but at the very least it can increase compile times.

  218. type ShowEq[A] = ShowT[A] with EqT[A]
  219. sealed trait ShowInstancesPriority2 extends AnyRef
  220. trait ShowIterable[A, R <: Iterable[A]] extends ShowTSeqLike[A, R]
  221. trait ShowPrecisonT[-T] extends PersistBase
  222. trait ShowProduct extends Show

    Trait for Show for product types.

    Trait for Show for product types. This trait is implemented directly by the type in question, unlike the corresponding ShowProductT trait which externally acts on an object of the specified type to create its String representations. For your own types ShowProduct is preferred over ShowProductT.

  223. trait ShowProductT[R] extends ShowCompoundT[R]

    The base trait for the persistence of algebraic product types, including case classes.

  224. trait ShowSimpleT[-A] extends ShowT[A]

    Shows a simple object like a Singleton object or a Double.

    Shows a simple object like a Singleton object or a Double. For your own objects that you control it is better to use Show and its helper sub rather than the sub traits of ShowT to implement your Show functionality.S

  225. trait ShowSingleton extends Show

    All the leaves of this trait must be Singleton objects.

    All the leaves of this trait must be Singleton objects. They just need to implement the str method. This will normally be the name of the object, but sometimes, it may be a lengthened or shortened version of the singleton object name.

  226. abstract class ShowSum2[ST <: AnyRef, A1 <: ST, A2 <: ST] extends ShowT[ST]

    Show class for algebraic sum types.

    Show class for algebraic sum types. If you are using your own code then Show sum types handled by inheritance.

  227. trait ShowT[-T] extends PersistBase

    A type class for string, text and visual representation of objects.

    A type class for string, text and visual representation of objects. An alternative to toString. This trait has mor demanding ambitions Mostly you will want to use Persist which not only gives the Show methods to String representation, but the methods to parse Strings back to objects of the type T. However it may often be useful to start with Show type class and upgrade it later to Persist[T].

  228. class ShowTExtensions[-A] extends AnyRef

    The stringer implicit class gives extension methods for Show methods from the implicit Show instance type A.

  229. trait ShowTSeqLike[A, R] extends ShowCompoundT[R]
  230. case class SomeA[+A, +B](value: A) extends OptEither[A, B] with Product with Serializable

    An OptEither instantiation that has a value of type A, the first type parameter.

  231. case class SomeB[+A, +B](value: B) extends OptEither[A, B] with Product with Serializable

    An OptEither instantiation that has a value of type B, the second type parameter.

  232. class SomeColour extends OptColour with SomeT[Colour]
  233. case class SomeInt(value: Int) extends OptInt with SomeT[Int] with Product with Serializable
  234. trait SomeT[A] extends Opt[A]
  235. trait SpecialArrT extends Any

    if you create your own specialist Arr class for a type T, make sure that type T extends SpecialT.

  236. trait SpecialT extends Any

    if you create your own specialist Arr class for a type T, make sure that type T extends SpecialT.

    if you create your own specialist Arr class for a type T, make sure that type T extends SpecialT. Traits that extend SpecialT are excluded from the implicit instance for Arr.

  237. final class StringImplicit extends AnyVal

    Extension methods for String.

    Extension methods for String. Brought into scope by the stringToImplicit method in the package object.

  238. case class StringIterableExtensions(iter: Iterable[String]) extends Product with Serializable
  239. final class Strings extends AnyVal with ArrImut[String]

    Immutable Array based class for Strings.

  240. final class StringsBuff extends AnyVal with ArrayLike[String]
  241. trait Sumable[A] extends AnyRef

    A type class for a sum like operation

  242. case class TextPosn(fileName: String, lineNum: Int, linePosn: Int) extends Product with Serializable
  243. trait TextSpan extends AnyRef
  244. trait TextSpanCompound extends TextSpan

    The purpose of this trait is to give the position span of the syntax from its opening and closing components.

  245. final class TimeDate extends AnyVal
  246. final class TimeSpan extends AnyVal
  247. implicit class Tuple2Implicit[A1, A2] extends AnyRef
  248. trait UnShow[+T] extends PersistBase

    The UnShow type class produces an object in memory or an error sequence from RSON syntax strings.

  249. trait UnShow2T[A1, A2, R] extends UnShowProduct[R] with Persist2Base[A1, A2, R]

    UnShow type class trait for a 2 element Product.

  250. class UnShow3[A1, A2, A3, R] extends UnShowProduct[R]

    UnShow class for 3 logical parameter product types.

  251. trait UnShow5[A1, A2, A3, A4, A5, R] extends UnShowProduct[R]

    Unshow trait for 5 parameter product / case classes.

  252. trait UnShow6[A1, A2, A3, A4, A5, A6, R] extends UnShowProduct[R]

    UnShow trait for 6 parameter product / case classes.

  253. trait UnShowProduct[R] extends UnShow[R]
  254. trait UnShowSum2[+ST <: AnyRef, A1 <: ST, A2 <: ST] extends UnShow[ST]
  255. trait ValueNArrCompanion[A <: ValueNElem, ArrA <: ValueNsArr[A]] extends AnyRef

    Helper trait for companion objects of ValueNsArr classes.

    Helper trait for companion objects of ValueNsArr classes. These are flat Array[Int], Array[Double] etc, flat collection classes.

  256. trait ValueNElem extends SpecialT

    A class that can be construct from a fixed number of homogeneous primitive values such as Ints, Doubles or Longs.

    A class that can be construct from a fixed number of homogeneous primitive values such as Ints, Doubles or Longs. The final class can be stored as an Array of primitive values. Note the classes that extend this trait do not extend Product or its numbered sub traits, because the logical size of the product may not be the same as the number of primitive values, for example a LineSeg is a product of 2 Pt2s, but is composed from 4 Double values.

  257. trait ValueNsArr[A <: ValueNElem] extends ArrImut[A]

    An immutable Arr of homogeneous value products.

    An immutable Arr of homogeneous value products. Currently there is no compelling use case for heterogeneous value products, but the homogeneous name is being used to avoid having to change the name if and when homogeneous value product Arrs are implemented.

  258. trait ValueNsArrBuilder[B <: ValueNElem, ArrB <: ValueNsArr[B]] extends ArrTBuilder[B, ArrB]

    Trait for creating the ArrTBuilder.

    Trait for creating the ArrTBuilder. Instances for the ArrTBuilder type class, for classes / traits you control, should go in the companion object of B. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  259. trait ValueNsArrFlatBuilder[B <: ValueNElem, ArrB <: ValueNsArr[B]] extends ArrTFlatBuilder[ArrB]

    Trait for creating the ArrTFlatBuilder type class instances for ValueNsArr final classes.

    Trait for creating the ArrTFlatBuilder type class instances for ValueNsArr final classes. Instances for the should go in the companion object the ArrT final class. The first type parameter is called B, because to corresponds to the B in map(f: A => B): ArrB function.

  260. abstract class ValueNsArrPersist[A, M] extends PersistCompound[M]

    Class to Persist specialised flat Array[Value] type based collections.

  261. trait ValueNsBuffer[A <: ValueNElem] extends ArrayLike[A]

    Specialised flat arraybuffer based collection class, where the underlying ArrayBuffer element is an atomic value like Int, Double or Long.

  262. final class Volume extends AnyVal

    Not sure about this class.

  263. final class WholeHours extends AnyVal
  264. trait WithColour extends AnyRef

    This trait provides a few handy methods for classes with the colour member

  265. final class Yards extends AnyVal with ImperialLength

    Length in yards.

Value Members

  1. implicit def AnyTypeToExtensions[T](thisT: T): AnyTypeExtensions[T]
  2. def Buff[A](initialLength: Int = 5): ArrayBuffer[A]
    Annotations
    @inline()
  3. val Cos30: Double
  4. val Cos60: Double
  5. def NoRef[A <: AnyRef]: OptRef[A]
  6. val Pi1: Double

    Pi.

    Pi. This has been named Pi1 to avoid a name clash if math._ is imported.

  7. val Pi2: Double

    2 * Pi.

  8. val PiOn2: Double

    Pi / 2

  9. val PiOn3: Double

    Pi / 3

  10. val PiOn4: Double

    Pi / 4

  11. val Sin30: Double
  12. val Sin60: Double
  13. val Sqrt2: Double

    The square root of 2.

  14. val Sqrt3: Double

    The square root of 3.

  15. val Tan30: Double
  16. implicit def arrayToExtensions[A](arr: Array[A]): ArrayExtensions[A]
  17. implicit def arrayValueNElemToExtensions[A <: ValueNElem](arr: Array[A]): ArrayValueNElemExtensions[A]
  18. def average(d1: Double, tail: Double*): Double

    Gives the average of the supplied values.

  19. def bad1[B](fs: TextSpan, detail: String): Bad[B]
  20. implicit def booleanToExtensions(b: Boolean): BooleanExtensions
  21. def buffInt(initialLength: Int = 5): ArrayBuffer[Int]
    Annotations
    @inline()
  22. implicit def charToExtensions(thisChar: Char): CharExtensions
  23. def commaedInts(iSeq: Int*): String
  24. implicit def doubleToExtensions(d: Double): DoubleImplicit
  25. def eTry[A](res: => A): EMon[A]
  26. def eqOf[A](leftValue: A, rightValues: A*): Boolean
  27. def excep(str: => String): Nothing
    Annotations
    @inline()
  28. def hypotenuse(side1: Double, side2: Double): Double

    Gives the scalar hypotenuse length for a right angled triangle form the paramter lengths of the other 2 sides.

  29. def iDblToMap[A, AA <: ArrImut[A]](iFrom: Double, iTo: Double, iStep: Double = 1)(f: (Double) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    Not sure if this correct.

    Not sure if this correct. This might throw on iStep = 0.

  30. def iToFlatMap[AA <: ArrImut[_]](iFrom: Int, iTo: Int, iStep: Int = 1)(f: (Int) => AA)(implicit ev: ArrTFlatBuilder[AA]): AA

    flatMaps over a range of Ints to an ArrBase[A].

    flatMaps over a range of Ints to an ArrBase[A]. From the start value to (while index is less than or equal to) the end value in integer steps. Default step value is 1. Throws on non termination.

  31. def iToFoldInt(iFrom: Int, iTo: Int, iStep: Int = 1, accInit: Int = 0)(f: (Int, Int) => Int): Int

    Folds over a range of Ints to an Int.

    Folds over a range of Ints to an Int. From the start value to (while index is less than or equal to) the end value in integer steps. Default step value is 1. Throws on non termination.

  32. def iToFoldSumInt(iFrom: Int, iTo: Int, iStep: Int = 1, accInit: Int = 0)(f: (Int) => Int): Int

    Folds over a range of Ints to an Int, adding the return Int value to the accumulator.

    Folds over a range of Ints to an Int, adding the return Int value to the accumulator. From the start value to (while index is less than or equal to) the end value in integer steps. Default step value is 1. Throws on non termination.

  33. def iToForeach(iFrom: Int, iTo: Int, iStep: Int = 1)(f: (Int) => Unit): Unit

    foreachs over a range of integers from parameter 1 to parameter 2 in steps of parameter 3.

    foreachs over a range of integers from parameter 1 to parameter 2 in steps of parameter 3. Throws on non termination.

  34. def iToMap[A, AA <: ArrImut[A]](iFrom: Int, iTo: Int, iStep: Int = 1)(f: (Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    maps over a range of Ints to an ArrBase[A].

    maps over a range of Ints to an ArrBase[A]. From the start value to (while index is less than or equal to) the end value in integer steps. Default step value is 1.

  35. def iUntilFoldInt(iFrom: Int, iUntil: Int, iStep: Int = 1, accInit: Int = 0)(f: (Int, Int) => Int): Int

    Folds over a range of Ints to an Int.

    Folds over a range of Ints to an Int. From the start value until (while index is less than) the end value in integer steps. Default step value is 1.

  36. def iUntilFoldSumInt(iFrom: Int, iUntil: Int, iStep: Int = 1, accInit: Int = 0)(f: (Int) => Int): Int

    Folds over a range of Ints to an Int adding the return Int value to the accumulator.

    Folds over a range of Ints to an Int adding the return Int value to the accumulator. From the start value until (while index is less than) the end value in integer steps. Default step value is 1.

  37. def iUntilForeach(iFrom: Int, iUntil: Int, iStep: Int = 1)(f: (Int) => Unit): Unit

    foreachs over a range of integers from parameter 1 until parameter 2 (while index is less than) in steps of parameter 3.

    foreachs over a range of integers from parameter 1 until parameter 2 (while index is less than) in steps of parameter 3. Throws on non termination.

  38. def iUntilMap[A, AA <: ArrImut[A]](iFrom: Int, iUntil: Int, iStep: Int = 1)(f: (Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    Maps a range of Ints to an ArrImut[A].

    Maps a range of Ints to an ArrImut[A]. From the start value until (while index is less than) the end value in integer steps. Default step value is 1. Throws on non termination.

  39. def if2Excep[A](b1: Boolean, vTrue1: => A, b2: Boolean, vTrue2: => A, excepStr: => String): A
    Annotations
    @inline()
  40. def if3Excep[A](b1: Boolean, vTrue1: => A, b2: Boolean, vTrue2: => A, b3: Boolean, vTrue3: => A, excepStr: => String): A
    Annotations
    @inline()
  41. def ifExcep(b: Boolean, str: => String): Unit
    Annotations
    @inline()
  42. def ifNotExcep(b: Boolean, str: => String): Unit
    Annotations
    @inline()
  43. def ife[A](b: Boolean, vTrue: => A, vFalse: => A): A

    if-else.

    if-else. If the condition is true, use 2nd parameter, else use 3rd parameter.

    Annotations
    @inline()
  44. def ife2[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, vElse: => A): A

    if-elseif-else.

    if-elseif-else. If the first condition is true, use 2nd parameter, else if the second condition in parameter 3 is true use 4th parameter.

    Annotations
    @inline()
  45. def ife3[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, b3: => Boolean, vTrue3: => A, vElse: => A): A
    Annotations
    @inline()
  46. def ife4[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, b3: => Boolean, vTrue3: => A, b4: => Boolean, vTrue4: => A, vElse: => A): A
    Annotations
    @inline()
  47. def ife5[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, b3: => Boolean, vTrue3: => A, b4: => Boolean, vTrue4: => A, b5: => Boolean, vTrue5: => A, vElse: => A): A
    Annotations
    @inline()
  48. def ifne[A](b: Boolean, vNotTrue: => A, visTrue: => A): A

    ifNot-else.

    ifNot-else. If the condition is false, use 2nd parameter, else use 3rd parameter.

    Annotations
    @inline()
  49. def ijSameToMap[A, AA <: ArrImut[A]](nFrom: Int, nTo: Int, nStep: Int = 1)(f: (Int, Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    ijToMap where i and j have identical ranges.

  50. def ijToForeach(iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(f: (Int, Int) => Unit): Unit

    2 dimensional from-to-step foreach loop.

    2 dimensional from-to-step foreach loop. Throws on non terminaton.

  51. def ijToMap[A, AA <: ArrImut[A]](iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(f: (Int, Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    2 dimensional map function.

    2 dimensional map function. i is the index for the outer loop. j is the index for the inner loop. maps over 2 ranges of Ints to an ArrBase[A]. From the start value to (while index is less than or equal to) the end value in integer steps. Default step values are 1.

  52. def ijUntilForeach(iFrom: Int, iUntil: Int, iStep: Int = 1)(jFrom: Int, jUntil: Int, jStep: Int = 1)(f: (Int, Int) => Unit): Unit
  53. def ijUntilMap[A, AA <: ArrImut[A]](iFrom: Int, iUntil: Int, iStep: Int = 1)(jFrom: Int, jUntil: Int, jStep: Int = 1)(f: (Int, Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    2 dimensional map function.

    2 dimensional map function. i is the index for the outer loop. j is the index for the inner loop. maps over 2 ranges of Ints to an ArrBase[A]. From the start value until (while index is less than) the end value in integer steps. Default step values are 1.

  54. def ijkToForeach(iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(kFrom: Int, kTo: Int, kStep: Int = 1)(f: (Int, Int, Int) => Unit): Unit

    3 dimensional from-to-step foreach loop.

    3 dimensional from-to-step foreach loop. Throws on non termination.

  55. def ijkToMap[A, AA <: ArrImut[A]](iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(kFrom: Int, kTo: Int, kStep: Int = 1)(f: (Int, Int, Int) => A)(implicit ev: ArrTBuilder[A, AA]): AA

    2 dimensional map function.

    2 dimensional map function. i is the index for the outer loop. j is the index for the inner loop. maps over 2 ranges of Ints to an ArrBase[A]. From the start value to (while index is less than or equal to) the end value in integer steps. Default step values are 1.

  56. implicit def intToExtensions(i: Int): IntExtensions
  57. implicit def iterableToExtensions[A](iter: Iterable[A]): IterableExtensions[A]
  58. implicit def iterableValueNElemToExtensions[A <: ValueNElem](iter: Iterable[A]): IterableValueNElemExtensions[A]
  59. implicit def listToExtensions[A](thisList: List[A]): ListExtensions[A]
  60. implicit def longToImplicit(i: Long): LongExtensions
  61. def oif[U](b: Boolean, vTrue: => Unit): Unit

    onlyIf-do.

    onlyIf-do. Only if the condition is true, perform the effect.

    Annotations
    @inline()
  62. implicit def optionToExtension[A](thisOption: Option[A]): OptionExtensions[A]
  63. def parseErr(fp: TextPosn, detail: String): String

    Not sure about this method.

  64. def readDouble: Double
  65. def readInt: Int
  66. def readT[T](implicit ev: Persist[T]): T

    Not sure what this method does.

  67. implicit def seqToExtensions[A](thisSeq: Seq[A]): SeqExtensions[A]
  68. implicit def show2TypeToExtensions[A1, A2, T](thisVal: T)(implicit ev: Show2T[A1, A2, T]): Show2TExtensions[A1, A2, T]
  69. implicit def showTypeToExtensions[A](thisVal: A)(implicit ev: ShowT[A]): ShowTExtensions[A]
  70. implicit def stringArrayToExtensions(strArray: Array[String]): StringIterableExtensions
  71. implicit def stringIterableToExtensions(strIter: Iterable[String]): StringIterableExtensions
  72. implicit def stringToExtensions(s: String): StringImplicit
  73. val two32: Long
  74. def twoIntsToDouble(i1: Int, i2: Int): Double
  75. object AlphaParenth
  76. object AlphaSquareParenth
  77. object ApproxT
  78. object Arr

    Companion object for the Arr class.

  79. object Arr0

    Extractor object for empty Arr[A].

    Extractor object for empty Arr[A]. Arr[A] is an immutable covariant Array based collection.

  80. object Arr1

    Extractor object for Arr[A] of length == 1.

    Extractor object for Arr[A] of length == 1. Arr[A] is an immutable covariant Array based collection.

  81. object Arr1Tail
  82. object Arr2

    Extractor object for Arr[A] of length == 2.

    Extractor object for Arr[A] of length == 2. Arr[A] is an immutable covariant Array based collection.

  83. object Arr2Tail
  84. object Arr3

    Extractor object for Arr[A] of length == 3.

    Extractor object for Arr[A] of length == 3. Arr[A] is an immutable covariant Array based collection.

  85. object Arr3Tail
  86. object Arr4

    Extractor object for Arr[A] of length == 4.

    Extractor object for Arr[A] of length == 4. Arr[A] is an immutable covariant Array based collection.

  87. object Arr5

    Extractor object for Arr[A] of length == 5.

    Extractor object for Arr[A] of length == 5. Arr[A] is an immutable covariant Array based collection.

  88. object Arr6

    Extractor object for Arr[A] of length == 6.

    Extractor object for Arr[A] of length == 6. Arr[A] is an immutable covariant Array based collection.

  89. object ArrArrayDblEq
  90. object ArrHead
  91. object ArrHead2

    Extractor object for the head 2 elements of an Arr, immutable covariant Array based collection.

    Extractor object for the head 2 elements of an Arr, immutable covariant Array based collection. The tail can be any length.

  92. object ArrHead3
  93. object ArrHead4
  94. case object ArrOff0 extends Product with Serializable

    Extractor for empty immutable heapless iterator for Arr.

  95. object ArrOff1

    Extractor object for an immutable heapless iterator for Arr with exactly 1 element.

  96. object ArrOff1Tail

    Extractor for immutable heapless iterator for Arr with at least l element.

  97. object ArrOff2

    Extractor object for an immutable heapless iterator for Arr with exactly 2 elements.

  98. object ArrOff2Tail
  99. object ArrOff3

    Extractor object for an immutable heapless iterator for Arr with exactly 3 elements.

  100. object ArrOffHead
  101. object ArrTBuilder extends ArrBuildLowPriority

    The companion object for ArrBuild contains implicit ArrBuild instances for common types.

  102. object ArrTFlatBuilder extends ArrFlatBuildLowPriority

    Companion object for ArrTFlatBuilder, contains implicit instances for atomic value classes.

  103. object Bad
  104. object Bad3
  105. object Base32LowerChar

    Extractor function object for a Base32 lower case letter, 'a' ..

    Extractor function object for a Base32 lower case letter, 'a' .. 'n' and 'p'.. 'w'.

  106. object Base32UpperChar

    Extractor function object for a Base32 upper case letter, 'A' ..

    Extractor function object for a Base32 upper case letter, 'A' .. 'N' and 'P'.. 'W'.

  107. object Booleans
  108. object BooleansBuild extends ArrTBuilder[Boolean, Booleans] with ArrTFlatBuilder[Booleans]
  109. object Chars

    Companion object of Chars class contains repeat parameter apply factor method.

  110. object CharsOff
  111. case object CharsOff0 extends Product with Serializable

    Extractor for empty immutable heapless iterator for Chars.

  112. object CharsOff1

    Extractor object for immutable heapless iterator for Chars with length == 1.

  113. object CharsOff1Tail

    Extractor for immutable heapless iterator for Chars with at l element.

  114. object CharsOff2

    Extractor object for immutable heapless iterator for Chars with length == 2.

  115. object CharsOff2Tail
  116. object CharsOff3

    Extractor object for immutable heapless iterator for Chars with length == 3.

  117. object CharsOff3Tail
  118. object CharsOff4

    Extractor object for immutable heapless iterator for Chars with length == 4.

  119. object CharsOff4Tail
  120. object CharsOffHead

    Extractor object for the first element for immutable heapless iterator for Chars with at length >= 1.

    Extractor object for the first element for immutable heapless iterator for Chars with at length >= 1. Use this when you don't care about the tail.

  121. object CharsOffHead2

    Extractor object for the first 2 elements for immutable heapless iterator for Chars with length >= 2.

    Extractor object for the first 2 elements for immutable heapless iterator for Chars with length >= 2. Use this when you don't care about the tail.

  122. object CharsOffHead3

    Extractor object for the first 3 elements for immutable heapless iterator for Chars with length >= 3.

    Extractor object for the first 3 elements for immutable heapless iterator for Chars with length >= 3. Use this when you don't care about the tail.

  123. object CharsOffHead4

    Extractor object for the first 3 elements for immutable heapless iterator for Chars with length >= 3.

    Extractor object for the first 3 elements for immutable heapless iterator for Chars with length >= 3. Use this when you don't care about the tail.

  124. object Colour

    Companion object for Colour class, contains named values for the standard web colours and implicit instances for various type classes.

  125. object Colours
  126. object Dbls

    Companion object for the Dbls Array based class for Doubles, contains a repeat parameter factory method.

  127. object DblsBuild extends ArrTBuilder[Double, Dbls] with ArrTFlatBuilder[Dbls]
  128. object DigitChar

    Extractor function object for digit character.

  129. object DigitCharNum

    Extractor function object for digit character.

  130. object EMon

    Companion object for EMon triat contains implict class for EMon returning extension methods on String and Show implicit instance.

  131. object Eq2T
  132. object Eq3T
  133. object EqT

    The campanion object for the EqT type class, containing instances for common types.

    The campanion object for the EqT type class, containing instances for common types. This does not currently use a functor instance for a number of reasons.

  134. object Floats
  135. object FloatsBuild extends ArrTBuilder[Float, Floats] with ArrTFlatBuilder[Floats]
  136. object Functor

    Companion object for the Functor type class, contains implicit instances.

  137. object GMetres

    Companion object for the GMetres GigaMeters (1000s of KMs) class contains apply factory method.

  138. object Good extends Serializable
  139. case object GoodArr0 extends Product with Serializable

    Extractor function object for a Good Arr Sequence of length 0.

  140. object GoodArr1

    Extractor function object for a Good Arr Sequence of length 1.

  141. object GoodArr2
  142. object GoodArr3
  143. object GoodArr4
  144. object HelloEmon extends App

    Test App for EMons.

  145. object HexaDigitChar

    Extractor function object for hexadecimal characters.

  146. object HexaLowerChar

    Extractor function object for lower case hexadecimal letter, 'a' ..

    Extractor function object for lower case hexadecimal letter, 'a' .. 'f'.

  147. object HexaUpperChar

    Extractor function object for upper case Hexadecimal letter, 'A' ..

    Extractor function object for upper case Hexadecimal letter, 'A' .. 'F'.

  148. object Hour
  149. object Ints
  150. object IntsBuild extends ArrTBuilder[Int, Ints] with ArrTFlatBuilder[Ints]
  151. object IsType
  152. object KMetres
  153. object Length

    Companion object for Length trait contains extension class for Length

  154. object LetterChar

    Extractor function object for letter character.

  155. object LetterLower

    Extractor function object for lower case letter character.

  156. object LetterOrDigitChar

    Extractor function object for letter or digit character.

  157. object LetterOrUnderscoreChar

    Extractor function object for letter or underscore.

  158. object LetterUpper

    Extractor function object for upper case letter character.

  159. object Longs
  160. object LongsBuild extends ArrTBuilder[Long, Longs] with ArrTFlatBuilder[Longs]
  161. object Metres

    Companion object for the class.

  162. object Miles

    Companion object for the class.

  163. object Minute
  164. object Multiple extends Serializable

    Companion object for the Multiple[+A] type class.

  165. object MyDbl2 extends Serializable
  166. object MyDbl2s extends Dbl2sArrCompanion[MyDbl2, MyDbl2s]
  167. case object NoColour extends OptColour with NoOpt[Colour] with Product with Serializable
  168. case object NoInt extends OptInt with NoOpt[Int] with Product with Serializable
  169. case object NoOptEither extends OptEither[Nothing, Nothing] with Product with Serializable

    An OptEither with a none value it has neither a value of type A or typeB,

  170. object NotSubTypeOf
  171. object OperatorChar

    Extractor object for operator characters.

  172. object OptRefs
  173. object Persist2

    Factory object for Persist product 2 type class

  174. object Persist3
  175. object Rval
  176. object Second
  177. object Setting
  178. object Show

    Companion object of the Show trait contains the Way trait, used by the show method on Show and the showT method on ShowT

  179. object Show2Base32sT
  180. object Show2DblsT
  181. object Show2ElemT
  182. object Show2IntsT
  183. object Show2T
  184. object Show5T
  185. object Show6T
  186. object ShowElemT
  187. object ShowPrecisonT
  188. object ShowSum2
  189. object ShowT
  190. object SomeColour
  191. object SomeRef
  192. object StrPosn
  193. object Strings

    Companion object of ArrStrings class contains repeat parameter apply factor method.

  194. object StringsBuild extends ArrTBuilder[String, Strings] with ArrTFlatBuilder[Strings]
  195. object Sumable
  196. object TextPosn extends Serializable
  197. object TextSpan
  198. object TextSpanCompound
  199. object TimeDate
  200. object TimeSpan
  201. object UnShow

    Companion object for the UnShow type class trait, contains implicit instances for common types.

  202. object WhitespaceChar

    Extractor object for whitespace characters.

  203. object WholeHours

Inherited from AnyRef

Inherited from Any

Ungrouped