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. LowPriority
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package geom

    I chose the package name to not clash with "geometry" that may be use in other libraries This package contains Basic geometry.

    I chose the package name to not clash with "geometry" that may be use in other libraries This package contains Basic geometry. 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.

  2. package pCanv

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

  3. package pDev
  4. package pEarth
  5. package pExt
  6. package pGames

    This pSimp contains the a number of games in varying stages of development.

  7. package pGrid

    This package works with hexagonal and Square tile grids.

    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.

  8. 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.

  9. package pSJs
  10. package pStrat

    Package for miscellaneous game utilities and data.

  11. package pWeb

    This package for the manipulation of Html, XML CSS and Javascript.

    This package for the manipulation of Html, XML CSS and Javascript. Some of the functionality could be replaced by Scalatags. As it currently stands the code and design quality of this package is not up to standard, but due to many other higher priorities, I have not been able to take the next step, which is to 1 improve and document it, rewrite it from scratch or 3 replace it with a Scala-tags dependency or some other library.

  12. package strat

Type Members

  1. type AnyRefs = Refs[AnyRef]
  2. type Arr[A] = ArraySeq[A]
  3. trait ArrBuffDbl2[A <: ProdDbl2, M <: ArrProdDbl2[A]] extends ArrBuffDblN[A, M]
  4. trait ArrBuffDblN[A, M <: ArrProdDblN[A]] extends ArrBuffHomo[A, M]
  5. trait ArrBuffHomo[A, M <: ArrProdHomo[A]] extends Any
  6. trait ArrBuffHomoInts[A, M <: ArrProdIntN[A]] extends ArrBuffHomo[A, M]

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

    A mutable collection of Elements that inherit from a Product of an Atomic value: Double, Int, Long or Float. They are stored with a backing ArrayBuffer[Int] They are named ProductIntsBuff rather than ProductIsBuff because that name can easlily be confused with ProductI1sBuff.

  7. trait ArrBuild[B, BB <: ArrImut[B]] extends AnyRef

    ArrBuilder[B, BB] is a type class for the building of efficient compact Immutable Arrays.

    ArrBuilder[B, BB] is a type class for the building of efficient compact Immutable Arrays. Instances for this typeclass for classes / traits you control should go in the companion object of B not the companion object of not BB. This is different from the related ArrBinder[BB] typeclass where instance should go into the BB companion object.

  8. trait ArrFlatBuild[BB <: ArrImut[_]] extends AnyRef

    ArrFlatBuild[BB] is a type class for the building of efficient compact Immutable Arrays through a bind method, which works similar to flatMap on standard Library collections.

    ArrFlatBuild[BB] is a type class for the building of efficient compact Immutable Arrays through a bind method, which works similar to flatMap on standard Library collections. It is called bind rather than flatMap partly to distinguish it and party so as it can be used as extension method on Standard Library collections. Instances for this typeclass for classes / traits you control should go in the companion object of BB. This is different from the related ArrBuild[BB] typeclass where the instance should go into the B companion object.

  9. abstract class ArrHomoDbl4Builder[A <: ProdDbl4, M <: ArrProdDbl4[A]] extends ArrProdDblNPersist[A, M]

    Both Persists and Builds ProductD4s Collection classes.

  10. abstract class ArrHomoDbl5Builder[A <: ProdDbl5, M <: ArrProdDbl5[A]] extends ArrProdDblNPersist[A, M]

    Both Persists and Builds ProductD4s Collection classes.

  11. trait ArrImut[+A] extends ArrayLike[A]

    Immutable Array.

    Immutable Array. 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. Name will be shortened to Arr once the laias for ArraySeq has been removed.

  12. type ArrMulti[A] = ArraySeq[Multiple[A]]
  13. final class ArrOff[A] extends AnyVal
  14. trait ArrProdDbl2[A <: ProdDbl2] extends ArrProdDblN[A]

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

  15. abstract class ArrProdDbl2Persist[A <: ProdDbl2, M <: ArrProdDbl2[A]] extends ArrProdDblNPersist[A, M]

    Both Persists and Builds ProductD2s collection classes.

  16. trait ArrProdDbl3[A <: ProdDbl3] extends ArrProdDblN[A]

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

  17. trait ArrProdDbl4[A <: ProdDbl4] extends ArrProdDblN[A]

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

  18. trait ArrProdDbl5[A <: ProdDbl5] extends ArrProdDblN[A]

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

  19. trait ArrProdDbl6[A <: ProdDbl6] extends ArrProdDblN[A]

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

  20. trait ArrProdDbl7[A <: ProdDbl7] extends ArrProdDblN[A]

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

  21. trait ArrProdDblN[A] extends ArrProdHomo[A]

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

  22. abstract class ArrProdDblNPersist[A, M <: ArrProdDblN[A]] extends ArrProdHomoPersist[A, M] with Eq[M]

    Persists and assists in building ArrProdDblN

  23. trait ArrProdHomo[A] extends ArrValues[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.

  24. abstract class ArrProdHomoPersist[A, M] extends PersistCompound[M]
  25. trait ArrProdInt1[A <: ProdInt1] extends ArrProdIntN[A]
  26. trait ArrProdInt2[A <: ProdInt2] extends ArrProdIntN[A]
  27. trait ArrProdInt4[A <: ProdInt4] extends ArrProdIntN[A]
  28. trait ArrProdIntN[A] extends ArrProdHomo[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.

  29. trait ArrProdLong1[A <: ProdLong1] extends ArrProdLongN[A]
  30. trait ArrProdLongN[A] extends ArrProdHomo[A]

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

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

  31. trait ArrValues[A] extends ArrImut[A]
  32. implicit class ArrayBufferDoubleExtensions extends AnyRef
  33. implicit class ArrayBufferExtensions[A] extends AnyRef
  34. implicit class ArrayExtension[A] extends AnyRef
  35. trait ArrayLike[+A] extends Any

    Base trait for Arr and BuffProducts and ArrayBuffer extension methods.

  36. case class Bad[+A](errs: StrList) extends EMon[A] with Product with Serializable

    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].

  37. type Buff[A] = ArrayBuffer[A]
  38. trait BuffProdDbl2[A <: ProdDbl2] extends Any
  39. final class Chars extends AnyVal with ArrImut[Char]
  40. final class CharsOff extends AnyVal

    Immutable heapless iterator for Char arrays.

  41. final class Colour extends AnyVal with ProdInt1

    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

  42. final class Colours extends AnyVal with ArrProdInt1[Colour]
  43. final class Dbls extends AnyVal with ArrImut[Double]
  44. 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.

  45. type EMonArr[A] = EMon[Arr[A]]
  46. type EMonList[A] = EMon[List[A]]
  47. type ERefs[A <: AnyRef] = EMon[Refs[A]]
  48. trait Eq[A] extends AnyRef
  49. class EqCase1[A1, R] extends Eq[R]
  50. class EqCase2[A1, A2, R] extends Eq[R]
  51. class EqCase3[A1, A2, A3, R] extends Eq[R]
  52. class EqCase4[A1, A2, A3, A4, R] extends Eq[R]
  53. class EqCase5[A1, A2, A3, A4, A5, R] extends Eq[R]
  54. class EqCase6[A1, A2, A3, A4, A5, A6, R] extends Eq[R]
  55. implicit class EqerImplicit[T] extends AnyRef
  56. type FStr = () => String
  57. type FStrSeq = Seq[() => String]
  58. trait Functor[F[_]] extends AnyRef
  59. implicit class FunitRichImp extends AnyRef
  60. 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[List[String], +A].

  61. trait IndentCon extends AnyRef
  62. trait Indenter extends IndentCon
  63. final class Ints extends AnyVal with ArrValues[Int]
  64. trait IsType[A <: AnyRef] extends AnyRef
  65. final class Longs extends AnyVal with ArrImut[Long]
  66. trait LowPriority extends AnyRef
  67. 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.

  68. type Not[T] = AnyRef { type L[U] = ostrat.NotSubTypeOf[U,T] }
  69. trait NotSubTypeOf[A, B] extends AnyRef
  70. final class Opt[A <: AnyRef] extends AnyVal
  71. sealed trait OptInt extends AnyRef
  72. type ParseExpr = Expr
  73. trait Persist[T] extends Show[T] with UnShow[T]

    The essential persistence type class.

    The essential persistence type class. it implements both a Show style type class interface, the production of a String representation of the value but also produces an EMon[T] from a String. It Persists and builds objects of type T from CRON syntax. So for example the IntImplicit object in the Persist companion object persists Integers and constructs Integers from Strings.

  74. class Persist1[A1, R] extends Show1[A1, R] with PersistCase[R]

    Persistence class for single parameter case classes.

    Persistence class for single parameter case classes. 2 Methods not implemented. not sure about this class or its sub class PersistD1.

  75. class Persist2[A1, A2, R] extends Show2[A1, A2, R] with PersistCase[R]

    Persistence class for 2 parameter case classes.

  76. class Persist3[A1, A2, A3, R] extends Show3[A1, A2, A3, R] with PersistCase[R]

    Persistence class for 3 parameter case classes.

  77. class Persist4[A1, A2, A3, A4, R] extends Show4[A1, A2, A3, A4, R] with PersistCase[R]

    Persistence class for 4 parameter case classes.

  78. class Persist5[A1, A2, A3, A4, A5, R] extends Show5[A1, A2, A3, A4, A5, R] with PersistCase[R]

    Persistence class for 5 parameter case classes.

  79. class Persist6[A1, A2, A3, A4, A5, A6, R] extends Show6[A1, A2, A3, A4, A5, A6, R] with PersistCase[R]

    Persistence class for 6 parameter case classes.

  80. trait PersistCase[R] extends ShowCase[R] with PersistCompound[R]

    The base trait for the persistence of Case classes, aka Product types

  81. trait PersistCompound[R] extends ShowCompound[R] with Persist[R]

    Persistence base trait for PersistCase and PerististSeqLike.

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

  82. class PersistD2[R] extends Persist2[Double, Double, R]

    Persistence class for case classes consisting of 2 Double parameters.

  83. abstract class PersistD3[R] extends Persist3[Double, Double, Double, R]

    Persistence class for case classes consisting of 3 Double parameters.

  84. class PersistDbl1[R] extends Persist1[Double, R]

    Persistence class for case classes taking a single Double parameter.

    Persistence class for case classes taking a single Double parameter. Not sure about this class. It is currently being used for Double based value classes. I think this is wrong and that they need their own trait class.

  85. type PersistEq[A] = Persist[A] with Eq[A]
  86. class PersistInt1[R] extends Persist1[Int, R]
  87. class PersistInt2[R] extends Persist2[Int, Int, R]

    Persistence class for case classes consisting of 2 Int parameters.

  88. abstract class PersistSimple[A] extends ShowSimple[A] with Persist[A]

    A Persist class described by a single value.

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

  89. trait PersistSingleton extends AnyRef

    all the leafs of this trait must be Singleton objects.

    all the leafs 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.

  90. abstract class PersistSingletons[A <: PersistSingleton] extends PersistSimple[A]
  91. abstract class PersistSum2[ST <: AnyRef, A1 <: ST, A2 <: ST] extends ShowSum2[ST, A1, A2] with UnShowSum2[ST, A1, A2] with Persist[ST]
  92. trait ProdDbl2 extends Product2[Double, Double] with ProdHomo

    Homogeneous Product2[Double, Double] with Stringer.

    Homogeneous Product2[Double, Double] with Stringer. These are used in ArrHomoDbl2 Array[Double] based collections.

  93. trait ProdDbl2sBuild[A <: ProdDbl2, ArrT <: ArrProdDbl2[A]] extends ArrBuild[A, ArrT]
  94. trait ProdDbl2sCompanion[T <: ProdDbl2, ST <: ArrProdDbl2[T]] extends ProdDblNsCompanion[T, ST]
  95. trait ProdDbl3 extends Product3[Double, Double, Double] with ProdHomo

    Homogeneous Product3[Double, Double, Double].

    Homogeneous Product3[Double, Double, Double]. These are used in ArrHomoDbl3 Array[Double] based collections.

  96. abstract class ProdDbl3sCompanion[A <: ProdDbl3, M <: ArrProdDbl3[A]] extends AnyRef
  97. trait ProdDbl4 extends Product4[Double, Double, Double, Double] with ProdHomo

    Homogeneous Product4[Double, Double, Double, Double].

    Homogeneous Product4[Double, Double, Double, Double]. These are used in ArrHomoDbl4 Array[Double] based collections.

  98. abstract class ProdDbl4sCompanion[A <: ProdDbl4, M <: ArrProdDbl4[A]] extends AnyRef
  99. trait ProdDbl5 extends Product5[Double, Double, Double, Double, Double] with ProdHomo

    Homogeneous Product5[Double, Double, Double, Double, Double].

    Homogeneous Product5[Double, Double, Double, Double, Double]. These are used in ArrHmoDbl5 Array[Double] based collections.

  100. abstract class ProdDbl5sCompanion[A <: ProdDbl5, M <: ArrProdDbl5[A]] extends AnyRef
  101. trait ProdDbl6 extends Product6[Double, Double, Double, Double, Double, Double] with ProdHomo

    Homogeneous Product6[Double, Double, Double, Double, Double, Double].

    Homogeneous Product6[Double, Double, Double, Double, Double, Double]. These are used in ArrHomoDbl6 Array[Double] based collections.

  102. abstract class ProdDbl6sCompanion[A <: ProdDbl6, M <: ArrProdDbl6[A]] extends AnyRef
  103. trait ProdDbl7 extends Product7[Double, Double, Double, Double, Double, Double, Double] with ProdHomo

    Homogeneous Product7[Double, Double, Double, Double, Double, Double, Double].

    Homogeneous Product7[Double, Double, Double, Double, Double, Double, Double]. These are used in ArrHomoDbl7 Array[Double] based collections.

  104. abstract class ProdDbl7sCompanion[A <: ProdDbl7, M <: ArrProdDbl7[A]] extends AnyRef
  105. trait ProdDblNsCompanion[T, ST <: ArrProdDblN[T]] extends AnyRef
  106. trait ProdHomo extends Any

    A homogeneous Product.

    A homogeneous Product. The final class can be stored as an Array of primitive values.

  107. trait ProdInt1 extends Any
  108. trait ProdInt2 extends Product2[Int, Int] with ProdHomo

    Homogeneous Product2[Int, Int] with Stringer.

    Homogeneous Product2[Int, Int] with Stringer. These are used in ArrHomoInt2s Array[Int] based collections.

  109. abstract class ProdInt2sBuilder[A <: ProdInt2, M <: ArrProdInt2[A]] extends ProductIntsBuilder[A, M]

    Persistence and Builder class for collections of Int products: ProdI2s.

  110. trait ProdInt4 extends Product4[Int, Int, Int, Int] with ProdHomo

    Homogeneous Product4[Int, Int, Int, Int] with Stringer.

    Homogeneous Product4[Int, Int, Int, Int] with Stringer. These are used in ArrHomoInt4 Array[Int] based collections.

  111. abstract class ProdInt4sCompanion[A <: ProdInt4, M <: ArrProdInt4[A]] extends AnyRef
  112. trait ProdLong1 extends Any
  113. trait ProductI1sBuff[A <: ProdInt1, M <: ArrProdInt1[A]] extends ArrBuffHomoInts[A, M]
  114. trait ProductI2sBuff[A <: ProdInt2, M <: ArrProdInt2[A]] extends ArrBuffHomoInts[A, M]
  115. abstract class ProductI2sCompanion[A <: ProdInt2, M <: ArrProdInt2[A]] extends ProductIntsCompanion[M]
  116. trait ProductI4sBuff[A <: ProdInt4, M <: ArrProdInt4[A]] extends ArrBuffHomoInts[A, M]
  117. abstract class ProductI4sBuilder[A <: ProdInt4, M <: ArrProdInt4[A]] extends ProductIntsBuilder[A, M]
  118. abstract class ProductIntsBuilder[A, M <: ArrProdIntN[A]] extends ArrProdHomoPersist[A, M]
  119. trait ProductIntsCompanion[M] extends AnyRef
  120. trait ProductL1sBuff[A <: ProdLong1, M <: ArrProdLong1[A]] extends ProductLongsBuff[A, M]
  121. trait ProductLongsBuff[A, M <: ArrProdLongN[A]] extends ArrBuffHomo[A, M]

    A mutable collection of Elements that inherit from a Product of an Atomic value: Double, Long, Long or Float.

    A mutable collection of Elements that inherit from a Product of an Atomic value: Double, Long, Long or Float. They are stored with a backing ArrayBuffer[Long] They are named ProductLongsBuff rather than ProductIsBuff because that name can easlily be confused with ProductI1sBuff.

  122. abstract class ProductLongsBuilder[A, M <: ArrProdLongN[A]] extends ArrProdHomoPersist[A, M]
  123. trait ProductLongsCompanion[M] extends AnyRef
  124. implicit class RefBufferExtensions[A <: AnyRef] extends AnyRef
  125. type RefTag[A] = ClassTag[A]
  126. final class Refs[+A <: AnyRef] extends AnyVal with ArrImut[A]
  127. final class RefsOff[A <: AnyRef] extends AnyVal

    Immutable heapless iterator for Refs.

  128. final class Rval extends AnyVal
  129. final class Sett extends AnyVal
  130. trait Show[-T] extends AnyRef

    The classic Show type class.

    The classic Show type class. A functional version of toString .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].

  131. abstract class Show1[A1, R] extends EqCase1[A1, R] with ShowCase[R]

    Show type class for 1 parameter case classes.

  132. class Show2[A1, A2, R] extends EqCase2[A1, A2, R] with ShowCase[R]

    Show type class for 2 parameter case classes.

  133. class Show3[A1, A2, A3, R] extends EqCase3[A1, A2, A3, R] with ShowCase[R]

    Show type class for 3 parameter case classes.

  134. abstract class Show4[A1, A2, A3, A4, R] extends EqCase4[A1, A2, A3, A4, R] with ShowCase[R]

    Show type class for 4 parameter case classes.

  135. class Show5[A1, A2, A3, A4, A5, R] extends EqCase5[A1, A2, A3, A4, A5, R] with ShowCase[R]

    Show type class for 5 parameter case classes.

  136. class Show6[A1, A2, A3, A4, A5, A6, R] extends EqCase6[A1, A2, A3, A4, A5, A6, R] with ShowCase[R]

    Show type class for 5 parameter case classes.

  137. trait ShowCase[R] extends ShowCompound[R]

    The base trait for the persistence of Case classes, aka Product types

  138. trait ShowCompound[R] extends Show[R]
  139. type ShowEq[A] = Show[A] with Eq[A]
  140. abstract class ShowSimple[-A] extends Show[A]
  141. abstract class ShowSum2[ST <: AnyRef, A1 <: ST, A2 <: ST] extends Show[ST]
  142. case class SomeInt(value: Int) extends OptInt with Product with Serializable
  143. type StrList = List[String]
  144. case class TextPosn(fileName: String, lineNum: Int, linePosn: Int) extends Product with Serializable
  145. trait TextSpan extends AnyRef
  146. trait TextSpanCompound extends TextSpan

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

  147. final class TimeDate extends AnyVal
  148. final class TimeSpan extends AnyVal
  149. implicit class Tuple2Implicit[A, B] extends AnyRef
  150. trait UnShow[+T] extends AnyRef
  151. trait UnShowSum2[+ST <: AnyRef, A1 <: ST, A2 <: ST] extends UnShow[ST]
  152. final class WholeHours extends AnyVal
  153. trait WithColour extends AnyRef

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

Value Members

  1. implicit def AnyTypeToExtensions[T](thisT: T): AnyTypeExtensions[T]
  2. def ArrWrap[A](mutArray: Array[A]): ArraySeq[A]
    Annotations
    @inline()
  3. def ArrWrapBuff[A](buff: ArrayBuffer[A])(implicit ct: ClassTag[A]): ArraySeq[A]
    Annotations
    @inline()
  4. def Buff[A](initialLength: Int = 5): ArrayBuffer[A]
    Annotations
    @inline()
  5. val Cos30: Float
  6. val Cos60: Double
  7. def Good3[A1, A2, A3](a1: A1, a2: A2, a3: A3): Good[(A1, A2, A3)]
  8. val Pi2: Double
  9. val PiH: Double
  10. val Sin30: Double
  11. val Sin60: Float
  12. val Tan30: Float
  13. implicit def arrToArrExtensions[A](thisArr: Arr[A]): ArrExtensions[A]
  14. implicit def arrayToExtensions[A](arr: Array[A]): ArrayExtensions[A]
  15. def bad1[B](fs: TextSpan, detail: String): Bad[B]
  16. def bad1[B](fp: TextPosn, detail: String): Bad[B]
  17. implicit def booleanToExtensions(b: Boolean): BooleanExtensions
  18. def buffInt(initialLength: Int = 5): ArrayBuffer[Int]
    Annotations
    @inline()
  19. implicit def charToExtensions(thisChar: Char): CharExtensions
  20. def commaedInts(iSeq: Int*): String
  21. def doubleFromTo(fromValue: Double, toValue: Double, step: Double): List[Double]
    Annotations
    @inline()
  22. implicit def doubleToExtensions(d: Double): DoubleImplicit
  23. def eTry[A](res: => A): EMon[A]
  24. def eqOf[A](leftValue: A, rightValues: A*): Boolean
  25. def excep(str: => String): Nothing
    Annotations
    @inline()
  26. def iToForeach(iFrom: Int, iTo: Int, iStep: Int = 1)(f: (Int) => Unit): Unit
  27. def iToMap[A](iFrom: Int, iTo: Int, iStep: Int = 1)(f: (Int) => A)(implicit ct: ClassTag[A]): Arr[A]
  28. def iUntilForeach(iFrom: Int, iUntil: Int, iStep: Int = 1)(f: (Int) => Unit): Unit
  29. def iUntilMap[A](iFrom: Int, iUntil: Int, iStep: Int = 1)(f: (Int) => A)(implicit ct: ClassTag[A]): Arr[A]
  30. def if2Excep[A](b1: Boolean, vTrue1: => A, b2: Boolean, vTrue2: => A, excepStr: => String): A
    Annotations
    @inline()
  31. def if3Excep[A](b1: Boolean, vTrue1: => A, b2: Boolean, vTrue2: => A, b3: Boolean, vTrue3: => A, excepStr: => String): A
    Annotations
    @inline()
  32. def ifExcep(b: Boolean, str: => String): Unit
    Annotations
    @inline()
  33. def ifNotExcep(b: Boolean, str: => String): Unit
    Annotations
    @inline()
  34. def ifSeq[A](b: Boolean, vTrue: => Seq[A]): Seq[A]
  35. def ifSeq1[A](b: Boolean, vTrue: => A): Seq[A]
  36. def ifSome[A](b: Boolean, vTrue: => A): Option[A]
  37. def ife[A](b: Boolean, vTrue: => A, vFalse: => A): A
    Annotations
    @inline()
  38. def ife2[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, vElse: => A): A
    Annotations
    @inline()
  39. def ife3[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, b3: => Boolean, vTrue3: => A, vElse: => A): A
    Annotations
    @inline()
  40. def ife4[A](b1: Boolean, vTrue1: => A, b2: => Boolean, vTrue2: => A, b3: => Boolean, vTrue3: => A, b4: => Boolean, vTrue4: => A, vElse: => A): A
    Annotations
    @inline()
  41. 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()
  42. def ifne[A](b: Boolean, vNotTrue: => A, visTrue: => A): A
    Annotations
    @inline()
  43. def iiToMap[A](nFrom: Int, nTo: Int, nStep: Int = 1)(f: (Int, Int) => A)(implicit ct: ClassTag[A]): Arr[A]
  44. def ijToForeach(iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(f: (Int, Int) => Unit): Unit
  45. def ijToMap[A](iFrom: Int, iTo: Int, iStep: Int = 1)(jFrom: Int, jTo: Int, jStep: Int = 1)(f: (Int, Int) => A)(implicit ct: ClassTag[A]): Arr[A]
  46. def ijUntilMap[A](iFrom: Int, iUntil: Int, iStep: Int = 1)(jFrom: Int, jUntil: Int, jStep: Int = 1)(f: (Int, Int) => A)(implicit ct: ClassTag[A]): Arr[A]
  47. implicit def intToExtensions(i: Int): IntExtensions
  48. implicit def iterableToExtensions[A](iter: Iterable[A]): IterableExtensions[A]
  49. implicit def listToExtensions[A](thisList: List[A]): ListExtensions[A]
  50. implicit def longToImplicit(i: Long): LongExtensions
  51. def nullRef[A <: AnyRef]: Opt[A]
  52. def oif[U](b: Boolean, vTrue: => Unit): Unit
    Annotations
    @inline()
  53. implicit def optionToExtension[A](thisOption: Option[A]): OptionExtensions[A]
  54. def parseErr(fp: TextPosn, detail: String): String

    Not sure about this method.

  55. def prints(objs: Any*): Unit
  56. def readDouble: Double
  57. def readInt: Int
  58. def readT[T](implicit ev: Persist[T]): T
  59. implicit def seqToExtensions[A](thisSeq: Seq[A]): SeqExtensions[A]
  60. implicit def show2TypeToExtensions[A1, A2, T](thisVal: T)(implicit ev: Show2[A1, A2, T]): Show2erTypeExtensions[A1, A2, T]
  61. implicit def showTypeToExtensions[A](thisVal: A)(implicit ev: Show[A]): ShowerTypeExtensions[A]
  62. implicit def stringArrayToExtensions(strArray: Array[String]): StringIterableExtensions
  63. implicit def stringIterableToExtensions(strIter: Iterable[String]): StringIterableExtensions
  64. implicit def stringToExtensions(s: String): StringImplicit
  65. val two32: Long
  66. def twoIntsToDouble(i1: Int, i2: Int): Double
  67. object Arr
  68. object Arr1
  69. object ArrBuild
  70. object ArrOff0
  71. object ArrOff1
  72. object ArrOff2
  73. object ArrOff3
  74. object ArrayLike
  75. object Bad extends Serializable
  76. object Chars
  77. object CharsOff0 extends Product with Serializable

    Extractor for empty immutable heapless iterator for Chars.

  78. object CharsOff1

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

  79. object CharsOff2
  80. object CharsOff3
  81. object CharsOff4
  82. object CharsOffHead

    Extractor object for the head only for immutable heapless iterator for Chars with at least 1 element.

  83. object Colour
  84. object Colours
  85. object Dbls
  86. object EMon
  87. object Eq

    The campanion object for the Eq typeclass, containing instances for common types.

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

  88. object EqCase2
  89. object EqCase3
  90. object Functor
  91. object Good extends Serializable
  92. object GoodRefs1
  93. object GoodRefs2
  94. object HelloEmon extends App
  95. object Hour
  96. object IndentCon
  97. object Ints
  98. object IsType
  99. object Longs
  100. object Minute
  101. object Multiple extends Serializable

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

  102. object NoInt extends OptInt with Product with Serializable
  103. object NotSubTypeOf
  104. object Opt
  105. object Persist

    Companion object for the persistence type class.

    Companion object for the persistence type class. Contains the implicit instances for Scala standard library types.

  106. object Persist2
  107. object Persist3
  108. object Persist4
  109. object Persist5
  110. object Persist6
  111. object Refs
  112. object Refs0

    Extractor object for empty Refs[A <: AnyRef].

    Extractor object for empty Refs[A <: AnyRef]. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  113. object Refs1

    Extractor object for Refs[A <: AnyRef] of length == 1.

    Extractor object for Refs[A <: AnyRef] of length == 1. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  114. object Refs1Tail
  115. object Refs2

    Extractor object for Refs[A <: AnyRef] of length == 2.

    Extractor object for Refs[A <: AnyRef] of length == 2. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  116. object Refs3

    Extractor object for Refs[A <: AnyRef] of length == 3.

    Extractor object for Refs[A <: AnyRef] of length == 3. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  117. object Refs4

    Extractor object for Refs[A <: AnyRef] of length == 4.

    Extractor object for Refs[A <: AnyRef] of length == 4. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  118. object Refs5

    Extractor object for Refs[A <: AnyRef] of length == 5.

    Extractor object for Refs[A <: AnyRef] of length == 5. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  119. object Refs6

    Extractor object for Refs[A <: AnyRef] of length == 6.

    Extractor object for Refs[A <: AnyRef] of length == 6. Refs[A <: AnyRef] is an immutable covariant Array based collection.

  120. object RefsHead
  121. object RefsOff0 extends Product with Serializable

    Extractor for empty immutable heapless iterator for Refs.

  122. object RefsOff1

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

  123. object RefsOffHead

    Extractor object for the head only for immutable heapless iterator for Refs with at least 1 element.

  124. object Rval
  125. object Second
  126. object Sett
  127. object Show
  128. object Show5
  129. object Show6
  130. object StrPosn
  131. object TextPosn extends Serializable
  132. object TextSpan
  133. object TextSpanCompound
  134. object TimeDate
  135. object TimeSpan
  136. object WholeHours

Inherited from LowPriority

Inherited from AnyRef

Inherited from Any

Ungrouped