Packages

p

scalaz

example

package example

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. sealed trait Token extends AnyRef

Value Members

  1. object A extends Token with Product with Serializable
  2. object AdjunctUsage extends App
  3. object ApplyUsage extends App
  4. object ArrowUsage extends App
  5. object B extends Token with Product with Serializable
  6. object BifunctorUsage extends App

    A Bifunctor is very similar to a Functor, which you are hopefully already familiar with.

    A Bifunctor is very similar to a Functor, which you are hopefully already familiar with. Whereas a Functor operates on a * → * and has a single operation map which takes a function from A => B to map a F[A] to a F[B], a Bifunctor operates on a *,* → * and has a single operation bimap which takes two functions: A => C and a B => D to map a F[A,B] to a F[C,D]:

    def bimap[A, B, C, D](fab: F[A, B])(f: A => C, g: B => D): F[C, D]

    some examples of common types for which we have Bifunctor instances are Either, Validation, \/, Tuple2

  7. object C extends Token with Product with Serializable
  8. object CABRunLengthEncoder
  9. object CaseInsensitiveUsage extends App
  10. object ContTUsage extends App
  11. object ContravariantCoyonedaUsage extends App
  12. object DirectTypeClassUsage extends App
  13. object DivideExample
  14. object EndoUsage extends App
  15. object EnumUsage extends App
  16. object FibStateExample extends App
  17. object FingerTreeUsage extends App
  18. object Foldable1Usage extends App
  19. object FoldableUsage extends App
  20. object FreeApUsage extends App
  21. object FreeMonadsUsage
  22. object FreeUsage extends App
  23. object FunctorUsage extends App

    A Functor is a ubiquitous typeclass involving type constructors of kind * -> *, which is another way of saying types that have a single type variable.

    A Functor is a ubiquitous typeclass involving type constructors of kind * -> *, which is another way of saying types that have a single type variable. Examples might be Option, List, Future.

    The Functor category involves a single operation, named map:

    def map[A, B](fa: F[A])(f: A => B): F[B]

    This method takes a Function from A => B and turns an F[A] into an F[B]

  24. object IListUsage extends App
  25. object IsomorphismUsage extends App
  26. object IterateeUsage extends App
  27. object KleisliUsage extends App
  28. object LaunchburyInterpreter extends App

    Simple call-by-need (i.e.

    Simple call-by-need (i.e. lazy) interpreter for Lambda Calculus based off of John Launchbury's "A Natural Semantics for Lazy Evaluation" Uses the "Barendregt convention": All variable names are globally unique (i.e. you cannot shadow variable names), and renames variables after substitution to maintain this invariant.

  29. object MixedBag extends App
  30. object MonadTransUsage extends App
  31. object NameNeedValueUsage extends App
  32. object NewTypeUsage extends App
  33. object PartiallyApplied extends App
  34. object ReaderWriterStateTUsage extends App
  35. object STUsage extends App
  36. object StateTUsage extends App
  37. object StringUsage extends App
  38. object SyntaxUsage extends App
  39. object TagUsage extends App

    scalaz contains a way to simulate something similar to a Haskell newtype, where we can take an existing type, and create a new type from it, and allow us to create new typeclass instances for our newly created type to get different behaviors.

    scalaz contains a way to simulate something similar to a Haskell newtype, where we can take an existing type, and create a new type from it, and allow us to create new typeclass instances for our newly created type to get different behaviors. The same thing could be done with scala 2.10's Value Classes: https://docs.scala-lang.org/overviews/core/value-classes.html however one has to be very careful when using value classes, because there are a lot of instances in which using a value class will incur a runtime boxing/unboxing of your value, which incurs a runtime cost. The scalaz tagged types will never cause boxing of a value that is already AnyRef.

  40. object Token
  41. object TrampolineUsage extends App
  42. object UnapplyInference extends App

    Examples showing the use of Unapply to reduce the need for type annotations

  43. object WordCount

    Character/Line/Word Count from "The Essence of the Iterator Pattern".

    Character/Line/Word Count from "The Essence of the Iterator Pattern".

    See also

    http://www.comlab.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf

  44. object WriterUsage extends App

Ungrouped